配置线程

import os
import json
from dotenv import load_dotenv

# 从 .env 文件加载环境变量
load_dotenv()

import openai
from langsmith import traceable, Client
from langsmith.wrappers import wrap_openai

# 初始化客户端
langsmith_client = Client()
client = wrap_openai(openai.Client())

# 配置
THREAD_ID = "thread-id-1"

# 使用本地目录存储线程历史。生产环境中请使用持久化存储方案。
THREADS_DIR = os.path.join(os.path.dirname(__file__), "threads")

# 获取线程中所有 LLM 调用的历史以构建对话历史
def get_thread_history(thread_id: str) -> list:
    path = os.path.join(THREADS_DIR, f"{thread_id}.json")
    if not os.path.exists(path):
        return []
    with open(path, "r") as f:
        return json.load(f)

def save_thread_history(thread_id: str, messages: list):
    os.makedirs(THREADS_DIR, exist_ok=True)
    with open(os.path.join(THREADS_DIR, f"{thread_id}.json"), "w") as f:
        json.dump(messages, f, indent=2, default=str)


@traceable(name="Chat Bot", metadata={"thread_id": THREAD_ID})
def chat_pipeline(messages: list, get_chat_history: bool = False):
    # 是继续现有线程还是开始新线程
    if get_chat_history:
        history_messages = get_thread_history(THREAD_ID)
        # 获取现有对话历史并追加新消息
        all_messages = history_messages + messages
    else:
        all_messages = messages

    # 调用模型
    chat_completion = client.chat.completions.create(
        model="gpt-4.1-mini", messages=all_messages
    )

    response_message = chat_completion.choices[0].message
    print("模型响应：", response_message)

    full_conversation = all_messages + [{"role": response_message.role, "content": response_message.content}]
    save_thread_history(THREAD_ID, full_conversation)

    return {"messages": full_conversation}


# 格式化消息
messages = [
    {
        "content": "你好，我叫 Sally",
        "role": "user"
    }
]

# 调用聊天流程
result = chat_pipeline(messages, get_chat_history=False)

import * as fs from "fs";
import * as path from "path";
import { fileURLToPath } from "url";
import * as dotenv from "dotenv";
import OpenAI from "openai";
import { traceable } from "langsmith/traceable";
import { wrapOpenAI } from "langsmith/wrappers";

const __dirname = path.dirname(fileURLToPath(import.meta.url));

// 从 .env 文件加载环境变量
dotenv.config();

// 初始化客户端
const client = wrapOpenAI(new OpenAI());

// 配置
const THREAD_ID = "thread-id-1";

// 使用本地目录存储线程历史。生产环境中请使用持久化存储方案。
const THREADS_DIR = path.join(__dirname, "threads");

type Message = { role: string; content: string };

// 获取线程中所有 LLM 调用的历史以构建对话历史
function getThreadHistory(threadId: string): Message[] {
  const filePath = path.join(THREADS_DIR, `${threadId}.json`);
  if (!fs.existsSync(filePath)) return [];
  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
}

function saveThreadHistory(threadId: string, messages: Message[]): void {
  fs.mkdirSync(THREADS_DIR, { recursive: true });
  fs.writeFileSync(
    path.join(THREADS_DIR, `${threadId}.json`),
    JSON.stringify(messages, null, 2)
  );
}

const chatPipeline = traceable(
  async function chatPipeline({ messages, get_chat_history = false }: { messages: Message[]; get_chat_history?: boolean }) {
    // 是继续现有线程还是开始新线程
    if (get_chat_history) {
      const historyMessages = getThreadHistory(THREAD_ID);
      // 获取现有对话历史并追加新消息
      messages = [...historyMessages, ...messages];
    }

    // 调用模型
    const chatCompletion = await client.chat.completions.create({
      model: "gpt-4.1-mini",
      messages,
    });

    const responseMessage = chatCompletion.choices[0].message;
    console.log("模型响应：", responseMessage);

    const fullConversation: Message[] = [
      ...messages,
      { role: responseMessage.role, content: responseMessage.content ?? "" },
    ];
    saveThreadHistory(THREAD_ID, fullConversation);

    return { messages: fullConversation };
  },
  { name: "Chat Bot", metadata: { thread_id: THREAD_ID } }
);

// 格式化消息
const messages: Message[] = [{ role: "user", content: "你好！我叫 Sally" }];

// 调用聊天流程
await chatPipeline({ messages, get_chat_history: false });

# 格式化消息
messages = [
    {
        "content": "我叫什么名字",
        "role": "user"
    }
]

# 调用聊天流程
result = chat_pipeline(messages, get_chat_history=True)

// 继续对话。
const messages: Message[] = [{ role: "user", content: "我叫什么名字" }];

await chatPipeline(messages, true);

# 继续对话。
messages = [
    {
        "content": "我发给你的第一条消息是什么？",
        "role": "user"
    }
]

chat_pipeline(messages, get_chat_history=True)

// 继续对话。
const messages: Message[] = [{ role: "user", content: "我发给你的第一条消息是什么？" }];

await chatPipeline(messages, true);