# 从 PyPI 安装
pip install honcho

# 或从源码安装
git clone https://github.com/plastic-labs/honcho.git
cd honcho
pip install -e .

# npm
npm install @plastic-labs/honcho

# yarn
yarn add @plastic-labs/honcho

# pnpm
pnpm add @plastic-labs/honcho

# Pinecone
pip install pinecone-client

# Weaviate
pip install weaviate-client

# Qdrant
pip install qdrant-client

from honcho import Memory, Store

# 创建记忆库（默认使用 SQLite）
store = Store(":memory:")  # 或使用文件路径 "memory.db"

# 创建用户记忆实例
mem = Memory(store, user_id="user_123")

# 记住用户信息
mem.remember("preference", "用户喜欢意式浓缩咖啡，不要加奶")
mem.remember("schedule", "用户通常早上 8 点喝咖啡")
mem.remember("health", "用户对乳糖不耐受")

# 检索相关记忆
context = mem.retrieve("用户想喝咖啡，推荐什么？")
print(context)
# 输出：
# "用户是咖啡爱好者，偏好意式浓缩，通常早上 8 点饮用。
#  注意用户对乳糖不耐受，建议避免含奶咖啡。"

# 融合多条记忆
fused = mem.fuse(["preference", "schedule", "health"])
print(fused)
# 输出融合后的连贯上下文

import { Memory, Store } from '@plastic-labs/honcho';

// 创建记忆库
const store = new Store(':memory:');  // 或使用文件路径 "memory.db"

// 创建用户记忆实例
const mem = new Memory(store, { userId: 'user_123' });

// 记住用户信息
await mem.remember('preference', '用户喜欢意式浓缩咖啡，不要加奶');
await mem.remember('schedule', '用户通常早上 8 点喝咖啡');
await mem.remember('health', '用户对乳糖不耐受');

// 检索相关记忆
const context = await mem.retrieve('用户想喝咖啡，推荐什么？');
console.log(context);

// 融合多条记忆
const fused = await mem.fuse(['preference', 'schedule', 'health']);
console.log(fused);

from honcho import Memory, Store, EmbeddingModel

# 使用自定义嵌入模型
model = EmbeddingModel("text-embedding-3-small")

store = Store("memory.db", embedding_model=model)
mem = Memory(store, user_id="user_123")

# 记住（自动生成嵌入）
mem.remember("coffee_pref", "用户喜欢意式浓缩")

# 检索（基于语义相似度）
results = mem.retrieve("喝咖啡", top_k=3)
for r in results:
    print(f"记忆: {r['content']} (相似度: {r['score']:.3f})")

class Store:
    def __init__(self, path: str = ":memory:",
                 embedding_model: Optional[EmbeddingModel] = None):
        """
        Args:
            path: 数据库路径（:memory: 表示内存）
            embedding_model: 嵌入模型（可选）
        """
        ...

    def export(self, path: str) -> None:
        """导出记忆库到文件"""
        ...

    def import_(self, path: str) -> None:
        """从文件导入记忆库"""
        ...

    def clear(self) -> None:
        """清空记忆库"""
        ...

from honcho import Memory, Store
from honcho.backends import PostgreSQLStore

# 连接 PostgreSQL
store = PostgreSQLStore(
    host="localhost",
    port=5432,
    database="honcho",
    user="postgres",
    password="password"
)

mem = Memory(store, user_id="user_123")
mem.remember("key", "value")

from honcho import Memory, Store
from honcho.backends import PineconeStore

# 连接 Pinecone
store = PineconeStore(
    api_key="your-api-key",
    environment="us-west1-gcp",
    index_name="honcho-memory"
)

mem = Memory(store, user_id="user_123")
mem.remember("key", "value")

# 检索（使用 Pinecone 的向量检索）
results = mem.retrieve("查询文本", top_k=3)

from honcho import EmbeddingModel

# 使用本地模型（不依赖外部 API）
class LocalEmbeddingModel(EmbeddingModel):
    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
        from sentence_transformers import SentenceTransformer
        self.model = SentenceTransformer(model_name)

    def embed(self, texts: List[str]) -> List[List[float]]:
        return self.model.encode(texts).tolist()

# 使用自定义模型
model = LocalEmbeddingModel()
store = Store("memory.db", embedding_model=model)

# 1. 安装 honcho
pip install honcho

# 2. 创建 SQLite 数据库
touch memory.db

# 3. 在代码中指定数据库路径
python your_agent.py

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["gunicorn", "app:app", "-b", "0.0.0.0:8000", "-w", "4"]

# 构建镜像
docker build -t honcho-agent .

# 运行容器
docker run -d -p 8000:8000 \
  -v $(pwd)/memory.db:/app/memory.db \
  honcho-agent