智能体记忆库plastic-labs/honcho

Static Badge
PyPI version
NPM version
CLI
Discord

Honcho 是用于构建有状态智能体的记忆基础设施，这些智能体能够理解随时间变化的人、智能体、群组、项目和想法。

存储消息和事件，让 Honcho 在后台进行推理，然后从任何模型或框架查询对等体表示、会话上下文、搜索结果或自然语言洞察。使用 api.honcho.dev 上的托管服务，通过 honcho start 运行本地技术栈，或自行托管 FastAPI 服务器。

将 Honcho 用作你的记忆系统，将为你的智能体赢得更高的留存率、更多的信任，并帮助你构建数据护城河，从而在与现有竞争者的较量中脱颖而出。

Honcho 定义了智能体记忆的帕累托前沿。观看视频，查看我们的评估页面，并阅读博客文章以了解更多细节。

目录

- 从这里开始
- 为什么选择 Honcho
- Honcho 循环
- 快速开始
- Honcho 为你提供什么
- 集成
- CLI
- 核心概念
- 基准测试与评估
- 自托管
- 配置
- 架构
- SDK
- 了解更多
- 贡献
- 许可证

Honcho 项目分布在多个代码仓库中，本仓库托管核心服务逻辑——以 FastAPI 服务器实现。Python 和 TypeScript 的客户端 SDK 位于 sdks/ 目录中。honcho-cli 包也位于此处。

从这里开始

| 我想要...                              | 路径                                                       | 开始使用                      |
| -------------------------------------- | ---------------------------------------------------------- | ----------------------------- |
| 为我的编码智能体提供持久记忆           | Claude Code、OpenCode、OpenClaw、Hermes 或任何 MCP 客户端 | 集成         |
| 为我的产品添加记忆               | Python 或 TypeScript SDK                                   | 快速开始     |
| 在本地运行 Honcho                     | 安装 CLI，然后运行 honcho start --setup                   | CLI                   |
| 检查部署                   | honcho workspace inspect、honcho doctor                | CLI                   |
| 从源码自托管                  | Docker Compose 或本地开发                        | 自托管 |

为什么选择 Honcho

| 能力              | 含义                                                                        |
| ----------------------- | ------------------------------------------------------------------------------------ |
| 推理优先的记忆  | 从对话和事件中提取结论，而不仅仅是匹配文本块。        |
| 以对等方为中心的模型      | 将用户、智能体、群组、项目和想法视为随时间变化的实体进行跟踪。 |
| 多对等方视角  | 在配置后，建模一个对等方对另一个对等方的了解。 |
| 托管或自托管  | 使用 api.honcho.dev、本地运行 honcho start，或自行运行 FastAPI 服务器。    |
| 智能体工具集成 | MCP、Claude Code、OpenCode、OpenClaw、Hermes、兼容 Cursor 的客户端。 |

Honcho 循环

1. 存储 对话、事件、文档或工具轨迹，作为会话上的消息。
2. 推理 — Honcho 在后台处理队列并更新对等方表示。
3. 查询 — 向 Honcho 请求上下文、搜索结果、对等方表示或自然语言答案。
4. 注入 — 将结果放入任何 LLM 调用或智能体框架中。

具体来说：工作区包含对等方，对等方参与会话，消息存在于会话上，Honcho 构建每个对等方的表示，你可以通过 Chat Endpoint 或直接查询。

快速开始

在 app.honcho.dev 获取 API 密钥——注册时，系统会提示你加入一个组织，该组织会获得自己专用的 Honcho 实例和 $100 免费额度。或者安装 CLI 并运行 honcho start --setup，然后将 SDK 指向 http://localhost:8000。

Python

pip install honcho-ai
or: uv add honcho-ai
or: poetry add honcho-ai

import os
from honcho import Honcho

Managed service uses api.honcho.dev by default. For self-hosted, pass
base_url="http://localhost:8000" or set HONCHO_URL.
honcho = Honcho(
workspace_id="my-app-testing",
api_key=os.environ["HONCHO_API_KEY"],
)

1. Store: peers and messages on a session
alice = honcho.peer("alice")
tutor = honcho.peer("tutor")
session = honcho.session("session-1")
session.add_messages([
alice.message("Hey there — can you help me with my math homework?"),
tutor.message("Absolutely. Send me your first problem!"),
])
2. 原因：在后台异步发生。

3. 查询：询问 Honcho 它知道什么，或拉取可直接用于提示词的上下文。
answer = alice.chat("What learning styles does the user respond to best?")
context = session.context(summary=True, tokens=10_000)

4. 注入：将上下文交给您选择的模型。
from openai import OpenAI
client = OpenAI()
completion = client.chat.completions.create(
model=os.environ.get("OPENAI_MODEL", "gpt-4o-mini"),
messages=context.to_openai(assistant=tutor),
)

TypeScript
bash
npm install @honcho-ai/sdk
or: bun add @honcho-ai/sdk
typescript
import { Honcho } from "@honcho-ai/sdk";
import OpenAI from "openai";

const honcho = new Honcho({
workspaceId: "my-app-testing",
apiKey: process.env.HONCHO_API_KEY,
});

const alice = await honcho.peer("alice");
const tutor = await honcho.peer("tutor");
const session = await honcho.session("session-1");
await session.addMessages([
alice.message("Hey there — can you help me with my math homework?"),
tutor.message("Absolutely. Send me your first problem!"),
]);

const answer = await alice.chat(
"What learning styles does the user respond to best?",
);
const context = await session.context({ summary: true, tokens: 10_000 });

const openai = new OpenAI();
const completion = await openai.chat.completions.create({
model: process.env.OPENAI_MODEL ?? "gpt-4o-mini",
messages: context.toOpenAI({ assistant: tutor }),
});

注意： 后台推理是异步的。新添加的消息可能需要一些时间才能反映在聊天/表示响应中；对于低延迟读取，请使用 representation 端点。

Honcho 为您提供什么

| 需求                               | API                                                             |
| ---------------------------------- | --------------------------------------------------------------- |
| 保存交互历史                       | session.add_messages(...)                                     |
| 询问 Honcho 关于某个对等方的了解   | peer.chat(...)                                                |
| 在整个工作区范围内询问             | honcho.chat(...) / honcho.chat_stream(...)                  |
| 获取可直接用于提示词的上下文       | session.context(...).to_openai(...) / .to_anthropic(...)    |
| 混合搜索（BM25 + 向量）            | peer.search(...), session.search(...), honcho.search(...) |
| 低延迟静态表示                     | peer.representation(...), session.representation(...)       |
| 导入文档                           | session.upload_file(...)                                      |
| 检查后台处理                       | honcho.queue_status(...)                                      |

请参阅完整的 SDK 参考 和 API 参考。

集成
Honcho 为每个主流编码代理都提供了第一方记忆插件。它们都读取同一个
~/.honcho/config.json，因此一个密钥即可配置所有插件——而将两个插件指向同一个 workspace
即可让它们共享一份记忆。

| 代理             | 安装                                                    | 源码                                                               |
| ---------------- | ------------------------------------------------------- | ------------------------------------------------------------------ |
| Claude Code      | /plugin marketplace add plastic-labs/claude-honcho    | claude-honcho     |
| Codex            | npm install -g @honcho-ai/codex-honcho                | codex-honcho       |
| Cursor           | curl -fsSL .../cursor-honcho/main/install.sh \| bash  | cursor-honcho     |
| DeepSeek Harness | dsh plugin --profile  add @honcho-ai/dsh-honcho | dsh-honcho           |
| OpenCode         | opencode plugin "@honcho-ai/opencode-honcho" --global | opencode-honcho |
| OpenClaw         | openclaw plugins install @honcho-ai/openclaw-honcho   | openclaw-honcho |
| Hermes           | hermes memory setup                                   | 上游内置                                                           |
| 任意 MCP 客户端  | claude mcp add honcho --transport http ...            | MCP 指南    |

在 app.honcho.dev 获取密钥，然后运行 honcho init（或 uv tool install honcho-cli && honcho init），它会将密钥一次性写入 ~/.honcho/config.json，供所有集成使用。

Claude Code

有两种方式，取决于你想深入到什么程度：

插件（集成更丰富——推荐 Claude Code 用户使用）：
text
/plugin marketplace add plastic-labs/claude-honcho
/plugin install honcho@honcho

原生 MCP（适用于任何 MCP 客户端——Cursor、Cline、Windsurf 等）：
bash
claude mcp add honcho \
--transport http \
--url "https://mcp.honcho.dev" \
--header "Authorization: Bearer hch-your-key-here" \
--header "X-Honcho-User-Name: YourName"

详情：Claude Code 指南 · MCP 指南 · 仓库。

Codex
bash
npm install -g @honcho-ai/codex-honcho
codex-honcho install      # registers hooks + MCP + skill in ~/.codex

重启 Codex 以加载钩子。详情：Codex 指南 · 仓库。

Cursor
bash
curl -fsSL https://raw.githubusercontent.com/plastic-labs/cursor-honcho/main/install.sh | bash

Windows（PowerShell）：irm https://raw.githubusercontent.com/plastic-labs/cursor-honcho/main/install.ps1 | iex。安装程序会配置全局钩子和 MCP 配置。详情：cursor-honcho。

DeepSeek Harness

dsh plugin --profile  add @honcho-ai/dsh-honcho

一个原生 Cordis 插件。它会将记忆注入系统提示词，并从会话事件流中捕获新信息。模型会获得三个工具——honcho_search、honcho_chat 和 honcho_remember——你可以运行 /honcho 来检查状态。
详情：DeepSeek Harness 指南 · 仓库。

OpenCode

opencode plugin "@honcho-ai/opencode-honcho" --global

详情：OpenCode 指南 · 仓库。

OpenClaw

openclaw plugins install @honcho-ai/openclaw-honcho
openclaw honcho setup
openclaw gateway --force

openclaw honcho setup 会提示你输入 API 密钥、写入配置，并可选地将旧版 MEMORY.md / USER.md / IDENTITY.md 文件迁移到 Honcho（非破坏性——原始文件绝不会被删除）。详情：OpenClaw 指南 · 仓库。

Hermes

hermes memory setup   # 选择 "honcho"，指向 api.honcho.dev 或你的本地服务器

详情：Hermes 指南。

将 Honcho 添加到自己的代码库（agent skill）

若要将 Honcho SDK 接入现有应用程序，请安装集成技能——它会探索你的代码库、询问集成偏好、生成 SDK 设置，并验证其可用：

npx skills add plastic-labs/honcho

然后在 Claude Code 中调用 /honcho-integration（或通过插件市场调用 /honcho-dev:integrate）。同一命令还会安装记忆技能——honcho-memory（概念：召回/记录循环、会话和对等策略，以及如何连接和驱动已连接 MCP 的 Honcho）和 honcho-cli（检查部署，或使用 honcho start 运行本地栈）。详情：agentic 开发指南。

其他 MCP 客户端

相同的 claude mcp add 形式（或其客户端特定的等效形式）适用于任何兼容 MCP 的客户端。参见 MCP 指南。

CLI

honcho-cli 可从终端检查 Honcho 部署，或使用 Docker 运行个人本地栈。

uv tool install honcho-cli
honcho init                 # Honcho API 密钥或浏览器登录 + 服务器 URL
honcho start --setup basic  # 本地技术栈：LLM 提供商密钥 + Docker
honcho doctor

honcho init 会让 CLI 针对 Honcho 服务器进行身份验证。honcho start --setup 是一个单独的步骤：它会写入本地 deriver 所需的 LLM 提供商密钥，并启动 API + deriver + Postgres + Redis。

完整命令和本地技术栈详情：CLI 参考 · honcho-cli/README.md。若要从源码开发服务器，请参阅自托管。

核心概念

Honcho 围绕 peers 组织一切——人类和 AI 代理同样是第一等实体。peer 模型支持：

- 人类与 AI 代理混合的多参与者会话
- 可配置的观察设置（哪些 peer 观察哪些其他 peer）
- 为所有参与者提供灵活的身份管理
- 支持复杂的多代理交互

Peers 在会话中交换消息；Honcho 对这些消息进行推理，以构建每个 peer 的表示，供你查询。

- Workspace（原 App）：顶层容器；在使用场景之间隔离数据。
- Peer（原 User）：任何参与者——人类用户或 AI 代理。
- Session：对话上下文；与 peers 为多对多关系。
- Scope：会话的命名分组，将召回（聊天、表示、搜索）限制在这些成员范围内。
- Message：原子数据单元（peer 对 peer 通信或摄取文档块）。

你可以从 Honcho 查询到的内容：

- Conclusions——Honcho 已提取的关于某个 peer 的内容（演绎和归纳）。通过 conclusions API 暴露。
- Representations——Honcho 所知道的关于某个 peer 的静态、低延迟快照（可选按会话限定范围）。
- Peer Cards——紧凑的身份摘要。
- Session context / summaries——用于长时间运行对话的、可直接用于提示词的打包内容。

内部存储（Collections 与 Documents）

在内部，Honcho 将 peer 相关观察存储在向量嵌入 documents 的 collections 中。Collections 以 (observer, observed) peer 对为键——同一机制支撑自我表示（observer == observed）和跨 peer 建模（peer X 对 peer Y 的理解）。这些原语不直接暴露；Conclusions API 是公开接口。

基准测试与评估
Honcho 的评估涵盖 LongMemEval、LoCoMo 以及其他长对话基准测试。有关方法论和可复现结果，请参阅评估页面、研究博客文章以及帕累托前沿公告视频。

自托管

Honcho 在 AGPL-3.0 下开源。要运行个人实例，请安装 CLI（uv tool install honcho-cli），然后执行 honcho start --setup。以下路径适用于从源代码构建、贡献代码或在没有 CLI 的情况下进行部署。

快速开始（从源代码，Docker）

git clone https://github.com/plastic-labs/honcho.git
cd honcho
cp docker-compose.yml.example docker-compose.yml
cp .env.template .env       # fill in LLM_GEMINI_API_KEY / LLM_ANTHROPIC_API_KEY / LLM_OPENAI_API_KEY
docker compose up

然后将 SDK 指向它：

honcho = Honcho(workspace_id="my-app-testing", base_url="http://localhost:8000")
or: export HONCHO_URL=http://localhost:8000

不使用 Docker 的本地开发

以下是在不使用 Docker 的情况下设置本地环境以运行 Honcho Server 的指南。

先决条件和依赖项

Honcho 使用 python 和 uv 开发。

最低 python 版本为 3.10
最低 uv 版本为 0.5.0

设置

在系统上安装依赖项后，运行以下步骤来完成
本地项目设置。

1. 克隆仓库

git clone https://github.com/plastic-labs/honcho.git

2. 进入仓库并安装 python 依赖项

我们建议使用虚拟环境，以将 Honcho 的依赖项与同一系统上的
其他项目隔离开来。当你在项目中同步依赖项时，uv 将创建一个虚拟环境。

cd honcho
uv sync

这将创建一个虚拟环境并安装 Honcho 的依赖项。
默认虚拟环境将位于 honcho/.venv。通过以下方式激活
虚拟环境：

source honcho/.venv/bin/activate

3. 设置数据库

Honcho 使用 Postgres 作为其数据库，并搭配
pgvector。开始使用 postgres 数据库的一种简单方法是使用
Supabase 创建一个项目。

或者，可以使用一个带有示例数据库配置的 docker-compose 模板。
要使用 Docker：

cp docker-compose.yml.example docker-compose.yml
docker compose up -d database

4. 编辑环境变量

Honcho 使用 .env 文件来管理运行时环境变量。为方便起见，
包含了一个 .env.template 文件。其中若干配置
不是必需的，仅在需要额外日志记录、监控和
安全时才是必要的。

以下是必需的配置：

DB_CONNECTION_URI= # postgres 数据库的连接 uri（带有 postgresql+psycopg 前缀）

LLM 提供商 API 密钥
LLM_GEMINI_API_KEY= # Google Gemini 的 API 密钥（默认用于 deriver、summary 以及 dialectic minimal/low）
LLM_ANTHROPIC_API_KEY= # Anthropic 的 API 密钥（默认用于 dialectic medium/high/max 以及 dream）
LLM_OPENAI_API_KEY= # OpenAI 的 API 密钥（当 EMBED_MESSAGES=true 时用于 embeddings）

请注意，DB_CONNECTION_URI 必须带有 postgresql+psycopg 前缀才能
正常工作。这是 sqlalchemy 带来的要求

该模板默认禁用了附加功能。为确保
它们已被禁用，你可以验证以下环境变量是否
设置为 false：

AUTH_USE_AUTH=false
SENTRY_ENABLED=false

如果你将 AUTH_USE_AUTH 设置为 true，则需要生成一个 JWT 密钥。你可以
使用以下命令来完成：

python scripts/generate_jwt_secret.py

这将生成一个 JWT 密钥并将其打印到控制台。然后你可以设置
AUTH_JWT_SECRET 环境变量。这是 AUTH_USE_AUTH 所必需的：

AUTH_JWT_SECRET=

启用 auth 后，使用 scripts/generate_jwt.py 为本地
开发和脚本编写铸造令牌：

管理员令牌（完全访问权限，无过期时间）
uv run python scripts/generate_jwt.py --admin

24 小时后过期的管理员令牌
uv run python scripts/generate_jwt.py --admin --expires 24h

工作区范围的令牌
uv run python scripts/generate_jwt.py --workspace my-workspace --expires 30d

捕获一个令牌以便在 curl/脚本中使用
TOKEN=$(uv run python scripts/generate_jwt.py --admin --print-only)
curl -H "Authorization: Bearer $TOKEN" http://localhost:8000/v3/workspaces

时长单位：s（秒）、m（分钟）、h（小时）、d（天）、w（周）、y（年）。

5. 运行数据库迁移

在数据库设置完成且环境变量配置好后，运行迁移
以创建必要的表：

uv run alembic upgrade head

这将为 Honcho 创建所有表，包括 workspaces、peers、sessions、
messages 以及队列系统。

6. 启动 Honcho

一切设置完成后，你现在可以启动 Honcho 的本地实例。除了数据库之外，还需要运行两个
组件：

启动 API 服务器：

uv run fastapi dev src/main.py

这是一个开发服务器，每当代码更改时都会重新加载。

启动后台 worker（deriver）：

在另一个终端中，运行：

uv run python -m src.deriver

deriver 会生成 representations、summaries、peer cards，并管理 dreaming 任务。你可以增加 deriver 的数量以提高运行时效率。

贡献者：关于提交前设置，请参阅 CONTRIBUTING.md。部署到 Fly.io：请参阅 自托管文档 → 在 Fly.io 上部署。

配置

Honcho 使用灵活的配置系统，同时支持 TOML 文件和环境变量。配置值按优先级顺序加载：环境变量 > .env 文件 > config.toml > 默认值。

复制示例文件即可开始：

cp config.toml.example config.toml

该文件按子系统组织——[app]、[db]、[auth]、[cache]、[llm]、[deriver]、[dialectic]、[summary]、[dream]、[peer_card]、[webhook]、[metrics]、[telemetry]、[vector_store] 和 [sentry]。任何值都可以通过名为 {SECTION}_{KEY} 的环境变量覆盖，嵌套时使用 __（DIALECTIC_LEVELS__low__MODEL_CONFIG__MODEL），或者对于应用级设置仅使用 {KEY}。

有关所有可用选项，请参阅配置参考，有关带注释的环境变量列表，请参阅 .env.template。

架构

Honcho 分为两个服务：Storage（工作区、对等体、会话、作用域、消息、内部集合）和 Insights（推理、结论、表示、摘要、聊天端点）。Storage 通过 API 同步进行；Insights 通过由 deriver 工作进程消费的后台队列异步进行。

主要特性：

- 丰富的推理系统 — 多种实现方法，从交互中提取结论并构建对等体的全面表示
- 聊天端点 — 基于推理的响应，将结论与当前上下文相结合
- 后台处理 — 针对表示更新和会话摘要等昂贵操作的异步处理管道
- 多提供商支持 — 可为不同用例配置的 LLM 提供商

存储原语详解

Honcho 包含若干用于存储应用程序和对等体数据的不同原语。这些数据用于管理对话、建模对等体身份、构建 RAG 应用程序等。

Honcho 背后的理念是提供一个以对等体为中心、可轻松从单个用户扩展到百万用户的平台。

以下是不同原语及其关系的映射。

Workspaces
├── Peers ←──────────────────┐
│   ├── Sessions             │
│   └── (internal collections, keyed by observer/observed peer pair)
│                            │
├── Scopes ←─────────────────┤ (many-to-many with sessions)
│                            │
└── Sessions ←───────────────┤ (many-to-many with peers)
├── Peers ───────────────┘
└── Messages (session-level)

关系详情：

- 一个 Workspace 包含多个 Peers 和 Scopes。
- Peers 和 Sessions 之间是多对多关系（peers 可以参与多个 sessions，sessions 可以有多个 peers）。
- Scopes 和 Sessions 之间是多对多关系（一个 session 可以属于多个 scopes；一个 scope 可以分组多个 sessions）。
- Messages 属于一个 session，并由其来源 peer 标记。
- 向量嵌入的 documents 的内部集合以 (observer, observed) peer 对为键。它们不直接通过 API 暴露；其中存储的 observations 以 Conclusions 的形式暴露。

熟悉 OpenAI Assistants API 等 API 的用户会熟悉
这里的许多映射关系。

Workspaces

这是 Honcho 的顶层构造。开发者可以为不同的
assistants、agents、AI 启用功能等注册不同的 Workspaces。这是一种在
用例之间隔离数据并提供多租户能力的方式。

Peers

在一个 Workspace 内，一切都围绕着一个 Peer。Peer 对象
代表系统中的任何参与者——无论是人类用户还是 AI agents。
这种统一模型支持复杂的多参与者交互。

Sessions

Session 对象表示 Workspace 内 Peers 之间的一组交互。
其他应用程序可能将其称为 thread 或 conversation。
Sessions 可以涉及多个 peers，并具有可配置的 observation 设置。
一个 session 可以在创建时可选地加入一个或多个 Scopes，或者稍后通过
scopes API 加入。

Scopes

Scope 是 Workspace 内 sessions 的命名分组。它是
recall 的可见性边界：通过一个 scope 回答的 chat、representation、session context 和
workspace search 只能看到该
scope 的成员 sessions 中发生的事情。底层 peers 在它们参与过的所有内容中保持统一的
representations。

开发者通过 scopes API（honcho.scope(...) /
honcho.scopes()）以及 session 创建时可选的一个 scopes 字段来管理 scopes——而不是
通过 observer/observed 配置。添加一个已有
messages 的 session 会将其现有的显式 conclusions 复制到该 scope 中（不会
重新推导）；移除一个 session 则会将这些副本协调移除。使用 scope 的 status 端点查询
backfill 进度。

单个 scope 名称会从该 scope 的 collection 和 card 中回答。一个 scope 列表
会将 recall 限制为其成员 sessions 的并集。空 scopes
会失败关闭。在同一次读取中，scope 与 session / filters 互斥。

Messages

Message 表示存在于 session 级别的原子数据单元：
session 上下文中 peers 之间的通信。所有 messages 都由其来源 peer 标记，并且可以异步处理以更新其
representations。这种灵活的设计允许既支持对话式交互，
也支持更广泛的数据摄取以进行 personality modelling。

推理流水线

Honcho 的推理功能构建在存储服务之上。当为 Peers 创建 Messages 和 Sessions 时，Honcho 会异步地对 peer 心理进行推理，以推导出关于它们的事实，并将其存储在保留的内部集合中。

该流水线的高层摘要如下：

1. 通过 API 创建消息。
2. 将派生任务加入队列以进行后台处理，包括：
- representation：更新 Peers 的表示。
- summary：创建 Sessions 的摘要。
3. 基于会话的队列处理确保正确的顺序。
4. 结果在内部存储，并通过 Conclusions API、Representations、Peer Cards 和 Chat Endpoint 对外提供。

检索数据和洞察

Honcho 提供了多种从系统中检索数据的方式，以最好地满足任何给定应用程序的需求。

获取上下文

在与 LLM 的长时间运行对话中，上下文窗口可能会很快被填满。为了解决这个问题，Honcho 提供了一个 context 端点，它返回会话中消息、结论、摘要的组合，直至达到所提供的 token 限制。

使用它可以让会话无限期地进行下去。如果你想看看它的实际效果，请试用 Honcho Chat。

搜索

有多个搜索端点允许开发者使用混合搜索策略在 Workspace、Session 或 Peer 级别查询消息。

请求可以包含高级过滤器以进一步细化结果。

Chat API

使用这些洞察的旗舰接口是 Chat Endpoint（POST /peers/{peer_id}/chat）。它接受自然语言请求以获取关于某个 peer 的数据，并返回基于推理的响应。示例：

- 向 Honcho 询问关于该 peer 的通用或具体洞察。
- 要求 Honcho 用关于该 peer 行为的数据来充实提示。
- 要求 Honcho 就如何回应提供第二意见。
- 获取融入长期事实和上下文的个性化响应。

Representations

对于低延迟用例，Honcho 提供了对 representation 端点的访问，它返回一个静态文档，其中包含在特定会话上下文中关于某个 peer 的洞察。使用它可以快速向提示添加上下文，而无需等待 LLM 响应。

SDKs

- Python — PyPI 上的 honcho-ai · 源代码位于 sdks/python/
- TypeScript — npm 上的 @honcho-ai/sdk · 源代码位于 sdks/typescript/
- CLI — PyPI 上的 honcho-cli · 源码位于 honcho-cli/ · CLI 参考

SDK 的版本独立于服务器进行版本管理。当前的 SDK 版本彼此保持同步；上方的服务器徽章反映的是已部署的服务器版本。

有关完整的 API 接口，请参阅 SDK 参考；有关原始 HTTP API，请参阅 API 参考；有关可运行的演示，请参阅各 SDK 的示例文件夹。

了解更多

- 开发者文档 — 完整的 API 接口、指南、集成。
- CLI 参考 — 本地技术栈、检查/调试命令、脚本编写。
- Plastic Labs 博客 — 设计理念与项目历史。

贡献

我们欢迎对 Honcho 的贡献。在开始之前，有一件事需要了解：拉取请求必须关联带有 maintainer-approved 标签的 issue，否则会被自动关闭。浏览已批准的队列，或在 Discord 中说明你的理由——维护者在那里最为活跃。

有关完整流程、架构讲解以及在哪里修改什么的指南，请参阅 CONTRIBUTING.md。有关漏洞，请参阅 SECURITY.md —— 请注意，Honcho 不运营漏洞赏金计划。

许可证

Honcho 依据 AGPL-3.0 许可证授权。了解更多信息，请参阅许可证文件。