# macOS / Linux（终端）
curl -sL https://daoshi.me/setup/mcp.sh | bash -s -- dsk_你的密钥

# Windows（PowerShell）
$env:DAOSHI_KEY="dsk_你的密钥"; irm https://daoshi.me/setup/mcp.ps1 | iex

memory_recall          回忆（输入问题，返回相关记忆；mode=verify 走确定性检索）
memory_store           保存对话
memory_forget          删除记忆 / 静音标签
memory_search_graph    搜索标签图
memory_stats           记忆库统计
DAOSHI_AI              教它认专名 / 同义词

memory://profile       画像卡
memory://recent        最近记忆
memory://graph/summary 图层概览

claude mcp add --transport http daoshi https://daoshi.me/mcp \
  --header "Authorization: Bearer dsk_你的密钥" --scope user

{
  "mcpServers": {
    "daoshi": {
      "type": "http",
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" }
    }
  }
}

{
  "mcpServers": {
    "daoshi": {
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" }
    }
  }
}

{
  "mcpServers": {
    "daoshi": {
      "serverUrl": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" }
    }
  }
}

{
  "inputs": [
    { "type": "promptString", "id": "daoshi-key", "description": "道识 API 密钥", "password": true }
  ],
  "servers": {
    "daoshi": {
      "type": "http",
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer ${input:daoshi-key}" }
    }
  }
}

{
  "mcpServers": {
    "daoshi": {
      "type": "streamableHttp",
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" },
      "disabled": false,
      "autoApprove": []
    }
  }
}

{
  "mcpServers": {
    "daoshi": {
      "type": "streamable-http",
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" },
      "alwaysAllow": [],
      "disabled": false
    }
  }
}

mcpServers:
  - name: daoshi
    type: streamable-http
    url: https://daoshi.me/mcp
    requestOptions:
      headers:
        Authorization: Bearer dsk_你的密钥

{
  "context_servers": {
    "daoshi": {
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" }
    }
  }
}

{ "mcpServers": { "daoshi": { "url": "https://daoshi.me/mcp?token=dsk_你的密钥" } } }

# 命令行（密钥走环境变量名，不写进配置）
export DAOSHI_KEY=dsk_你的密钥
codex mcp add daoshi --url https://daoshi.me/mcp --bearer-token-env-var DAOSHI_KEY

# 或直接写 ~/.codex/config.toml
[mcp_servers.daoshi]
url = "https://daoshi.me/mcp"
http_headers = { "Authorization" = "Bearer dsk_你的密钥" }

gemini mcp add --transport http --header "Authorization: Bearer dsk_你的密钥" daoshi https://daoshi.me/mcp

{
  "mcpServers": {
    "daoshi": {
      "httpUrl": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" },
      "timeout": 60000
    }
  }
}

qwen mcp add --transport http daoshi https://daoshi.me/mcp --header "Authorization: Bearer dsk_你的密钥"

kimi mcp add --transport http daoshi https://daoshi.me/mcp --header "Authorization: Bearer dsk_你的密钥"

{
  "mcpServers": {
    "daoshi": {
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" }
    }
  }
}

{
  "mcpServers": {
    "daoshi": {
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" },
      "disabled": false,
      "autoApprove": []
    }
  }
}

copilot mcp add --transport http --header "Authorization: Bearer dsk_你的密钥" daoshi https://daoshi.me/mcp

{
  "mcpServers": {
    "daoshi": {
      "type": "http",
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" },
      "tools": ["*"]
    }
  }
}

# macOS:   ~/Library/Application Support/Claude/claude_desktop_config.json
# Windows: %APPDATA%\Claude\claude_desktop_config.json
{
  "mcpServers": {
    "daoshi": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://daoshi.me/mcp",
               "--header", "Authorization:${AUTH_HEADER}",
               "--transport", "http-only"],
      "env": { "AUTH_HEADER": "Bearer dsk_你的密钥" }
    }
  }
}

{
  "mcpServers": {
    "daoshi": {
      "type": "streamableHttp",
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" }
    }
  }
}

{
  "mcpServers": {
    "daoshi": {
      "url": "https://daoshi.me/mcp",
      "headers": { "Authorization": "Bearer dsk_你的密钥" }
    }
  }
}

from openai import OpenAI
client = OpenAI()
resp = client.responses.create(
    model="gpt-5",
    input="我住哪里？",
    tools=[{
        "type": "mcp",
        "server_label": "daoshi",
        "server_url": "https://daoshi.me/mcp",
        "headers": {"Authorization": "Bearer dsk_你的密钥"},
        "require_approval": "never",
    }],
)
print(resp.output_text)

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-client-2025-11-20" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "max_tokens": 1000,
    "messages": [{"role": "user", "content": "我住哪里？"}],
    "mcp_servers": [{"type": "url", "url": "https://daoshi.me/mcp", "name": "daoshi",
                     "authorization_token": "dsk_你的密钥"}],
    "tools": [{"type": "mcp_toolset", "mcp_server_name": "daoshi"}]
  }'

tools=[{
    "type": "mcp_server",
    "name": "daoshi",
    "url": "https://daoshi.me/mcp",
    "headers": {"Authorization": "Bearer dsk_你的密钥"}
}]

curl -s -i https://daoshi.me/mcp \
  -H "Authorization: Bearer dsk_你的密钥" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"0"}}}'

pnpm check:mcp        # 临时库跑一遍真实握手 + 存取，不碰你的记忆

# 兜底上游
export DAOSHI_UPSTREAM_BASE_URL=https://api.openai.com
export DAOSHI_UPSTREAM_KEY=sk-你的OpenAI密钥

# 具名上游（只匹配特定 model 前缀）
export DAOSHI_UPSTREAM_DEEPSEEK_BASE_URL=https://api.deepseek.com/v1
export DAOSHI_UPSTREAM_DEEPSEEK_KEY=sk-你的DeepSeek密钥
export DAOSHI_UPSTREAM_DEEPSEEK_MODELS=deepseek-

# Python · OpenAI SDK
client = OpenAI(base_url="https://daoshi.me/v1", api_key="dsk_你的道识密钥")

# Python · Anthropic SDK
client = Anthropic(base_url="https://daoshi.me", api_key="dsk_你的道识密钥")

# Node.js
const client = new OpenAI({ baseURL: "https://daoshi.me/v1", apiKey: "dsk_你的道识密钥" });

# curl
curl -X POST https://daoshi.me/v1/chat/completions \
  -H "Authorization: Bearer dsk_你的道识密钥" \
  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"你好"}]}'

curl -s -i https://daoshi.me/v1/chat/completions \
  -H "Authorization: Bearer dsk_你的密钥" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"你好，请记住我喜欢咖啡"}]}' \
  | grep -i -E "^x-memory|\"content\""

# 响应头
X-Memory-Status: injected | skipped | degraded
X-Memory-Skip:   off | tool-loop | not-conversational | ...

# 请求头：逐轮控制
X-Memory: off              # 这一轮不存不取
X-Memory-Session: my-chat  # 指定会话号（不传就按对话内容自动归组）
X-Memory-Debug: 1          # 非流式时返回调试信封：注入了什么、真正发给上游的是什么

import requests

class Daoshi:
    def __init__(self, base_url, api_key, session_id=None):
        self.base = base_url.rstrip("/")
        self.h = {"Authorization": f"Bearer {api_key}"}
        self.session_id = session_id

    def _post(self, path, body):
        r = requests.post(self.base + path, json=body, headers=self.h, timeout=10)
        r.raise_for_status()
        return r.json()

    def store(self, content, role="user"):
        body = {"items": [{"role": role, "content": content}]}
        if self.session_id: body["sessionId"] = self.session_id
        return self._post("/v1/memories", body)

    def store_turn(self, user_said, ai_replied):
        body = {"items": [{"role": "user", "content": user_said},
                          {"role": "assistant", "content": ai_replied}]}
        if self.session_id: body["sessionId"] = self.session_id
        return self._post("/v1/memories", body)

    def recall(self, query, mode="associative"):
        return self._post("/v1/recall", {"query": query, "mode": mode}).get("block", "")

    def forget(self, memory_ids=None, mute_tag=None):
        return self._post("/v1/forget", {"memoryIds": memory_ids, "tag": mute_tag})

    def stats(self):
        return requests.get(self.base + "/v1/stats", headers=self.h, timeout=10).json()

# 对话循环
from openai import OpenAI
mem = Daoshi("https://daoshi.me", "dsk_你的密钥")
ai = OpenAI()

def chat(user_input):
    memory = mem.recall(user_input)
    messages = ([{"role": "system", "content": memory}] if memory else []) \
             + [{"role": "user", "content": user_input}]
    reply = ai.chat.completions.create(model="gpt-4o", messages=messages).choices[0].message.content
    mem.store_turn(user_input, reply)
    return reply

const BASE = "https://daoshi.me", KEY = "dsk_你的密钥";
const h = { Authorization: "Bearer " + KEY, "Content-Type": "application/json" };

async function recall(query) {
  const r = await fetch(BASE + "/v1/recall", { method: "POST", headers: h, body: JSON.stringify({ query }) });
  return (await r.json()).block ?? "";
}
async function storeTurn(userSaid, aiReplied) {
  await fetch(BASE + "/v1/memories", { method: "POST", headers: h, body: JSON.stringify({
    items: [{ role: "user", content: userSaid }, { role: "assistant", content: aiReplied }],
  }) });
}

// 对话循环
import OpenAI from "openai";
const ai = new OpenAI();
async function chat(userInput) {
  const memory = await recall(userInput);
  const messages = memory ? [{ role: "system", content: memory }] : [];
  messages.push({ role: "user", content: userInput });
  const resp = await ai.chat.completions.create({ model: "gpt-4o", messages });
  const reply = resp.choices[0].message.content;
  await storeTurn(userInput, reply);
  return reply;
}

npm i ./daoshi-sdk-0.3.0.tgz

import { createMemory } from "@daoshi/sdk";

const mem = createMemory({ path: "./my-memory.db" });   // 一个文件就是全部记忆

await mem.remember("我家的橘猫叫饭团");
const block = await mem.recall("我家猫叫什么");         // 空串 = 没有达标记忆

await mem.rememberTurn("用户说的", "AI 回的");
await mem.forget({ memoryIds: [12] });
await mem.forget({ tag: "咖啡" });                        // 静音一个标签
await mem.learnWord("尹雪光", "person");                 // 教它认专名
await mem.recallDetailed("我家猫叫什么");                // 条目、分数、命中标签、耗时
await mem.stats();                                       // 记忆条数、标签图规模
await mem.close();                                       // 用完必须 close

#include <curl/curl.h>
#include <nlohmann/json.hpp>
using json = nlohmann::json;

class DaoshiMemory {
    std::string base_url, api_key;
public:
    DaoshiMemory(const std::string& url, const std::string& key)
        : base_url(url), api_key(key) {}

    void store(const std::string& content, const std::string& role = "user") {
        json body = {{"items", {{{"role", role}, {"content", content}}}}};
        post("/v1/memories", body.dump());
    }

    std::string recall(const std::string& query) {
        json body = {{"query", query}};
        auto resp = post("/v1/recall", body.dump());
        return json::parse(resp).value("block", "");
    }
private:
    std::string post(const std::string& path, const std::string& body);
    // libcurl POST，带 Authorization: Bearer 头
};

// 语音助手主循环
DaoshiMemory mem("https://daoshi.me", "dsk_你的密钥");
void on_user_speech(const std::string& text) {
    std::string memory = mem.recall(text);
    std::string prompt = memory.empty() ? text : memory + "\n\nUser: " + text;
    std::string reply = call_llm(prompt);
    mem.store(text, "user");
    mem.store(reply, "assistant");
    speak(reply);  // TTS 输出
}

// Java — OkHttp
public class DaoshiMemory {
    private final OkHttpClient client = new OkHttpClient();
    private final String baseUrl, apiKey;

    public DaoshiMemory(String baseUrl, String apiKey) {
        this.baseUrl = baseUrl; this.apiKey = apiKey;
    }

    public String recall(String query) throws Exception {
        JSONObject body = new JSONObject().put("query", query);
        Request req = new Request.Builder()
            .url(baseUrl + "/v1/recall")
            .header("Authorization", "Bearer " + apiKey)
            .post(RequestBody.create(body.toString(),
                  MediaType.parse("application/json")))
            .build();
        try (Response resp = client.newCall(req).execute()) {
            return new JSONObject(resp.body().string()).optString("block", "");
        }
    }

    public void store(String content, String role) throws Exception {
        JSONObject item = new JSONObject().put("role", role).put("content", content);
        JSONObject body = new JSONObject().put("items", new JSONArray().put(item));
        Request req = new Request.Builder()
            .url(baseUrl + "/v1/memories")
            .header("Authorization", "Bearer " + apiKey)
            .post(RequestBody.create(body.toString(),
                  MediaType.parse("application/json")))
            .build();
        client.newCall(req).execute().close();
    }
}

// Kotlin
val mem = DaoshiMemory("https://daoshi.me", "dsk_你的密钥")
val memory = mem.recall("我叫什么")

package daoshi

import ("bytes"; "encoding/json"; "net/http")

type Memory struct{ BaseURL, APIKey string }

func (m *Memory) Recall(query string) (string, error) {
    body, _ := json.Marshal(map[string]string{"query": query})
    req, _ := http.NewRequest("POST", m.BaseURL+"/v1/recall",
        bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+m.APIKey)
    req.Header.Set("Content-Type", "application/json")
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return "", err }
    defer resp.Body.Close()
    var result struct{ Block string }
    json.NewDecoder(resp.Body).Decode(&result)
    return result.Block, nil
}

func (m *Memory) Store(content, role string) error {
    type Item struct{ Role, Content string }
    body, _ := json.Marshal(map[string]any{
        "items": []Item{{role, content}},
    })
    req, _ := http.NewRequest("POST", m.BaseURL+"/v1/memories",
        bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+m.APIKey)
    req.Header.Set("Content-Type", "application/json")
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return err }
    resp.Body.Close()
    return nil
}

// 使用
mem := &Memory{"https://daoshi.me", "dsk_你的密钥"}
block, _ := mem.Recall("我家猫叫什么")

import Foundation

class DaoshiMemory {
    let baseURL: String, apiKey: String
    init(baseURL: String, apiKey: String) {
        self.baseURL = baseURL; self.apiKey = apiKey
    }

    func recall(_ query: String) async throws -> String {
        var req = URLRequest(url: URL(string:
            "\(baseURL)/v1/recall")!)
        req.httpMethod = "POST"
        req.setValue("Bearer \(apiKey)",
            forHTTPHeaderField: "Authorization")
        req.setValue("application/json",
            forHTTPHeaderField: "Content-Type")
        req.httpBody = try JSONSerialization.data(
            withJSONObject: ["query": query])
        let (data, _) = try await URLSession.shared.data(for: req)
        let json = try JSONSerialization.jsonObject(with: data)
            as? [String: Any]
        return json?["block"] as? String ?? ""
    }

    func store(_ content: String, role: String = "user")
        async throws {
        var req = URLRequest(url: URL(string:
            "\(baseURL)/v1/memories")!)
        req.httpMethod = "POST"
        req.setValue("Bearer \(apiKey)",
            forHTTPHeaderField: "Authorization")
        req.setValue("application/json",
            forHTTPHeaderField: "Content-Type")
        req.httpBody = try JSONSerialization.data(
            withJSONObject: ["items": [
                ["role": role, "content": content]
            ]])
        _ = try await URLSession.shared.data(for: req)
    }
}

let mem = DaoshiMemory(baseURL: "https://daoshi.me", apiKey: "dsk_你的密钥")
let memory = try await mem.recall("我明天要做什么")

# 核心接口
POST /v1/memories                 # 写入记忆
POST /v1/recall                   # 检索记忆

# 管理接口
GET  /v1/stats                    # 统计
GET  /v1/profile                  # 画像
GET  /v1/recent                   # 最近记忆
GET  /v1/graph                    # 标签图
POST /v1/forget                   # 软删 / 静音
POST /v1/flush                    # 推进打标队列
POST /v1/dict                     # 词典管理

# 认证
Authorization: Bearer dsk_你的密钥

# 能力域
memory:read  memory:write  memory:forget
memory:purge  dict:write  admin

curl -X POST https://daoshi.me/v1/memories \
  -H "Authorization: Bearer dsk_你的密钥" \
  -H "Content-Type: application/json" \
  -d '{"items":[{"role":"user","content":"我家的橘猫叫饭团"}]}'

curl -X POST https://daoshi.me/v1/recall \
  -H "Authorization: Bearer dsk_你的密钥" \
  -H "Content-Type: application/json" \
  -d '{"query":"我家宠物叫什么"}'

# 返回 {"block":"以下是你说过的：...","items":[...],"empty":false}

curl https://daoshi.me/v1/stats -H "Authorization: Bearer dsk_你的密钥"
curl https://daoshi.me/v1/profile -H "Authorization: Bearer dsk_你的密钥"
curl -X POST https://daoshi.me/v1/forget -H "Authorization: Bearer dsk_你的密钥" \
  -d '{"memoryIds":[42]}'

# LangChain
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o", base_url="https://daoshi.me/v1", api_key="dsk_你的密钥")

# LlamaIndex
from llama_index.llms.openai import OpenAI
llm = OpenAI(model="gpt-4o", api_base="https://daoshi.me/v1", api_key="dsk_你的密钥")

# CrewAI
from crewai import LLM
llm = LLM(model="openai/gpt-4o", base_url="https://daoshi.me/v1", api_key="dsk_你的密钥")

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableLambda

mem = Daoshi("https://daoshi.me", "dsk_你的密钥")      # 见「Python」页那 30 行封装
llm = ChatOpenAI(model="gpt-4o")
prompt = ChatPromptTemplate.from_messages([("system", "{memory}"), ("human", "{input}")])

def inject(x):
    return {"input": x["input"], "memory": mem.recall(x["input"]) or "（无相关记忆）"}

chain = RunnableLambda(inject) | prompt | llm

def chat(user_input):
    reply = chain.invoke({"input": user_input}).content
    mem.store_turn(user_input, reply)      # 钩子二：写回
    return reply