多代理系统

import { Annotation, StateGraph, START, END } from '@langchain/langgraph';
import { ChatOpenAI } from '@langchain/openai';
import { HumanMessage, SystemMessage } from '@langchain/core/messages';

const State = Annotation.Root({
  messages: Annotation<Array<{ role: string; content: string }>>({
    reducer: (a, b) => a.concat(b),
    default: () => [],
  }),
  next: Annotation<'coder' | 'writer' | 'finish'>({
    default: () => 'finish',
  }),
  draft: Annotation<string>({
    default: () => '',
  }),
});

const supervisorModel = new ChatOpenAI({
  model: 'gpt-4o-mini',
  temperature: 0,
});

const supervisorNode = async (state: typeof State.State) => {
  const decision = await supervisorModel.invoke([
    new SystemMessage(
      '你是主管。请输出 next 的值：coder / writer / finish。\n- coder：写代码\n- writer：写文档\n- finish：结束\n只输出一个单词。',
    ),
    ...state.messages.map((m) => new HumanMessage(m.content)),
  ]);

  const raw = String(decision.content).trim().toLowerCase();
  const next = raw.includes('coder')
    ? 'coder'
    : raw.includes('writer')
      ? 'writer'
      : 'finish';
  return { next };
};

const coderNode = async (state: typeof State.State) => ({
  draft: state.draft + '\n// coder: implement TODO...\n',
});

const writerNode = async (state: typeof State.State) => ({
  draft: state.draft + '\n// writer: explain design...\n',
});

const routeNext = (state: typeof State.State) => {
  if (state.next === 'coder') return 'coder';
  if (state.next === 'writer') return 'writer';
  return END;
};

export const multiAgentApp = new StateGraph(State)
  .addNode('supervisor', supervisorNode)
  .addNode('coder', coderNode)
  .addNode('writer', writerNode)
  .addEdge(START, 'supervisor')
  .addConditionalEdges('supervisor', routeNext)
  .addEdge('coder', 'supervisor')
  .addEdge('writer', 'supervisor')
  .compile();

const summarizerNode = async (state: typeof State.State) => {
  const prompt = `请把以下草稿汇总为清晰的最终答复：\n${state.draft}`;
  const summary = await supervisorModel.invoke([new HumanMessage(prompt)]);
  return { draft: String(summary.content) };
};

const app = new StateGraph(State)
  .addNode('supervisor', supervisorNode)
  .addNode('coder', coderNode)
  .addNode('writer', writerNode)
  .addNode('summarize', summarizerNode)
  .addEdge(START, 'supervisor')
  .addConditionalEdges('supervisor', routeNext)
  .addEdge('coder', 'supervisor')
  .addEdge('writer', 'supervisor')
  .addEdge('supervisor', 'summarize')
  .addEdge('summarize', END)
  .compile();

const decisionSchema = z.object({
  next: z.enum(['coder', 'writer', 'finish']),
  reason: z.string(),
});

const decision = await supervisorModel
  .withStructuredOutput(decisionSchema)
  .invoke([
    new SystemMessage('请输出 next 和 reason 字段'),
    ...state.messages.map((m) => new HumanMessage(m.content)),
  ]);

return { next: decision.next };

// 定义一个工具，用于转移控制权
const transferToSupport = tool(
  () => 'Successfully transferred to Support Agent',
  { name: 'transfer_to_support', description: 'Transfer user to support team' },
);

import { END, StateGraph } from '@langchain/langgraph';

const routeByTool = (state: typeof State.State) => {
  const last = state.messages[state.messages.length - 1];
  const hasTransfer = last?.tool_calls?.some(
    (call) => call.name === 'transfer_to_support',
  );
  if (hasTransfer) return 'support';
  return END;
};

const app = new StateGraph(State)
  .addNode('sales', salesNode)
  .addNode('support', supportNode)
  .addEdge(START, 'sales')
  .addConditionalEdges('sales', routeByTool)
  .addEdge('support', END)
  .compile();

const GlobalState = Annotation.Root({
  goal: Annotation<string>(),
  summary: Annotation<string>(),
});

const AgentPrivateState = Annotation.Root({
  messages: Annotation<BaseMessage[]>({
    reducer: messagesStateReducer,
    default: () => [],
  }),
  scratchpad: Annotation<string>({
    default: () => '',
  }),
});

const collectResults = (state: typeof State.State) => ({
  draft: [state.resultA, state.resultB, state.resultC].join('\n'),
});

const app = new StateGraph(State)
  .addNode('agentA', agentA)
  .addNode('agentB', agentB)
  .addNode('agentC', agentC)
  .addNode('merge', collectResults)
  .addEdge(START, 'agentA')
  .addEdge(START, 'agentB')
  .addEdge(START, 'agentC')
  .addEdge('agentA', 'merge')
  .addEdge('agentB', 'merge')
  .addEdge('agentC', 'merge')
  .compile();