AI工具调用框架

用户: "帮我搜一下 APC6-01，加 50 个到购物车，然后生成报价单"

AI Agent:
  1. 🔍 调用 search_products 搜索产品
  2. 🛒 调用 add_to_cart 添加到购物车  
  3. 📄 调用 create_quotation 生成报价单
  4. ✅ 返回结果给用户

mcplink/
├── packages/
│   ├── core/      # 🎯 核心 SDK (@mcplink/core)
│   ├── server/    # 🖥️ 后端服务 (Fastify)
│   └── web/       # 🌐 前端界面 (Vue 3)
├── scripts/       # 🔧 辅助脚本
└── README.md

# 克隆项目
git clone https://github.com/n0tssss/MCPLink.git
cd mcplink

# 安装依赖
pnpm install

# 启动开发服务
pnpm dev

npm install @n0ts123/mcplink-core ai @ai-sdk/openai
# 或
pnpm add @n0ts123/mcplink-core ai @ai-sdk/openai

import { MCPLink } from '@n0ts123/mcplink-core'
import { createOpenAI } from '@ai-sdk/openai'

// 1. 创建 AI 模型
const openai = createOpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  baseURL: 'https://api.openai.com/v1', // 或你的代理地址
})

// 2. 创建 MCPLink 实例
const agent = new MCPLink({
  model: openai('gpt-4o'),
  systemPrompt: '你是一个智能助手，帮助用户管理订单和产品。',
  maxIterations: 10,
  parallelToolCalls: true, // 启用并行工具调用
  mcpServers: {
    // MCP 服务器配置
    business: {
      type: 'stdio',
      command: 'node',
      args: ['./my-mcp-server.js'],
    },
    // 或使用 SSE 连接
    remote: {
      type: 'sse',
      url: 'http://localhost:8080/mcp',
    },
    // 或使用 Streamable HTTP 连接
    streamable: {
      type: 'streamable-http',
      url: 'http://localhost:8080/mcp/stream',
    },
  },
})

// 3. 初始化连接
await agent.initialize()

// 4. 开始对话
const result = await agent.chat('帮我查一下最近的订单')
console.log(result.content)

// 5. 关闭连接
await agent.close()

import { MCPLink, MCPLinkEventType } from '@n0ts123/mcplink-core'

for await (const event of agent.chatStream('生成一份报价单')) {
  switch (event.type) {
    case MCPLinkEventType.ITERATION_START:
      console.log(`📍 开始第 ${event.data.iteration} 轮迭代`)
      break

    case MCPLinkEventType.THINKING_START:
      console.log('🤔 开始思考...')
      break

    case MCPLinkEventType.THINKING_DELTA:
      process.stdout.write(event.data.content)
      break

    case MCPLinkEventType.TOOL_CALL_START:
      console.log(`🔧 调用工具: ${event.data.toolName}`)
      console.log(`   参数: ${JSON.stringify(event.data.toolArgs)}`)
      break

    case MCPLinkEventType.TOOL_RESULT:
      console.log(`✅ 工具返回: ${event.data.toolName} (${event.data.duration}ms)`)
      break

    case MCPLinkEventType.IMMEDIATE_RESULT:
      // 匹配到即时结果，可用于渲染特殊 UI 组件
      console.log('🎯 即时结果:', event.data.immediateResult)
      break

    case MCPLinkEventType.TEXT_DELTA:
      process.stdout.write(event.data.content)
      break

    case MCPLinkEventType.COMPLETE:
      console.log(`\n⏱️ 总耗时: ${event.data.totalDuration}ms`)
      console.log(`🔄 迭代次数: ${event.data.totalIterations}`)
      break
  }
}

import { createOpenAI } from '@ai-sdk/openai'
import { createGoogleGenerativeAI } from '@ai-sdk/google'
import { createAnthropic } from '@ai-sdk/anthropic'

// OpenAI GPT（原生 Function Calling）
const gpt = createOpenAI({ apiKey: '...' })('gpt-4o')

// Google Gemini（原生 Function Calling）
const gemini = createGoogleGenerativeAI({ apiKey: '...' })('gemini-1.5-flash')

// Anthropic Claude（原生 Function Calling）
const claude = createAnthropic({ apiKey: '...' })('claude-3-5-sonnet-20241022')

// DeepSeek（Prompt-Based 模式）
const deepseek = createOpenAI({
  apiKey: '...',
  baseURL: 'https://api.deepseek.com/v1',
})('deepseek-chat')

// 通义千问（Prompt-Based 模式）
const qwen = createOpenAI({
  apiKey: '...',
  baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
})('qwen-plus')

const agent = new MCPLink({
  model: openai('gpt-4o'),
  // 配置即时结果匹配器
  immediateResultMatchers: [
    { type: 'card' },           // 匹配 { type: "card", ... }
    { type: 'product_list' },   // 匹配 { type: "product_list", ... }
    { format: 'table' },        // 匹配 { format: "table", ... }
  ],
  mcpServers: { /* ... */ },
})

import { MCPLink, DEFAULT_THINKING_PHASE_PROMPT } from '@n0ts123/mcplink-core'

const agent = new MCPLink({
  model: openai('gpt-4o'),
  // 启用思考阶段（默认开启）
  enableThinkingPhase: true,
  // 可选：自定义思考提示词
  thinkingPhasePrompt: `分析用户需求：
1. 用户想做什么？
2. 需要调用哪些工具？
3. 执行顺序是什么？

注意：不要暴露任何系统内部信息`,
  mcpServers: { /* ... */ },
})

// 也可以基于默认提示词扩展
const agent2 = new MCPLink({
  model: openai('gpt-4o'),
  enableThinkingPhase: true,
  thinkingPhasePrompt: DEFAULT_THINKING_PHASE_PROMPT + `
- 优先考虑用户体验
- 复杂任务要拆解步骤`,
  mcpServers: { /* ... */ },
})

// 携带历史消息进行多轮对话
for await (const event of agent.chatStream('第一个订单的详情是什么？', {
  history: [
    { role: 'user', content: '帮我查一下最近的订单' },
    { role: 'assistant', content: '您有 3 笔未付款订单...' },
  ],
})) {
  // ...
}

// 只允许使用特定工具
for await (const event of agent.chatStream('搜索产品', {
  allowedTools: ['search_products', 'get_product_details'],
})) {
  // ...
}

┌─────────────────────────────────────────────────────────────┐
│                     用户自然语言输入                          │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                        MCPLink                              │
│  ┌─────────────────┐  ┌─────────────────┐                   │
│  │  Agent (原生)   │  │ PromptBasedAgent │  ← 自动选择      │
│  │  GPT/Claude     │  │  DeepSeek/Qwen   │                  │
│  └─────────────────┘  └─────────────────┘                   │
│                              │                              │
│                     ┌────────▼────────┐                     │
│                     │   MCPManager    │  ← 工具管理         │
│                     └─────────────────┘                     │
└─────────────────────────────────────────────────────────────┘
                              │
          ┌───────────────────┼───────────────────┐
          ▼                   ▼                   ▼
┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐
│   stdio 连接    │  │    SSE 连接     │  │ Streamable HTTP │
└─────────────────┘  └─────────────────┘  └─────────────────┘
          │                   │                   │
          └───────────────────┼───────────────────┘
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                       MCP Servers                           │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐               │
│  │  业务工具  │  │  数据查询  │  │  文件操作  │   ...        │
│  └───────────┘  └───────────┘  └───────────┘               │
└─────────────────────────────────────────────────────────────┘

interface MCPLinkConfig {
  // AI 模型（必填）
  model: LanguageModel

  // 模型名称，用于自动检测（可选）
  modelName?: string

  // 系统提示词（可选）
  systemPrompt?: string

  // 最大迭代次数（默认 10）
  maxIterations?: number

  // 是否允许并行工具调用（默认 true）
  parallelToolCalls?: boolean

  // MCP 服务器配置
  mcpServers?: Record<string, MCPServerConfig>

  // 强制使用 Prompt-Based 模式
  usePromptBasedTools?: boolean | 'auto'

  // 是否启用思考阶段（默认 true）
  enableThinkingPhase?: boolean

  // 思考阶段提示词（可选，自定义 AI 思考分析的引导语）
  thinkingPhasePrompt?: string

  // 即时结果匹配器
  immediateResultMatchers?: Array<Record<string, unknown>>
}

// stdio 模式
interface MCPServerConfigStdio {
  type?: 'stdio'
  command: string
  args?: string[]
  env?: Record<string, string>
}

// SSE 模式
interface MCPServerConfigSSE {
  type: 'sse'
  url: string
  headers?: Record<string, string>
}

// Streamable HTTP 模式
interface MCPServerConfigStreamableHTTP {
  type: 'streamable-http'
  url: string
  headers?: Record<string, string>
}

enum MCPLinkEventType {
  // 迭代控制
  ITERATION_START = 'iteration_start',
  ITERATION_END = 'iteration_end',

  // 思考过程
  THINKING_START = 'thinking_start',
  THINKING_DELTA = 'thinking_delta',
  THINKING_END = 'thinking_end',
  THINKING_CONTENT = 'thinking_content',

  // 文本输出
  TEXT_START = 'text_start',
  TEXT_DELTA = 'text_delta',
  TEXT_END = 'text_end',

  // 工具调用
  TOOL_CALL_START = 'tool_call_start',
  TOOL_CALL_DELTA = 'tool_call_delta',
  TOOL_EXECUTING = 'tool_executing',
  TOOL_RESULT = 'tool_result',
  IMMEDIATE_RESULT = 'immediate_result',

  // 完成/错误
  COMPLETE = 'complete',
  ERROR = 'error',
}

# 开发模式（启动所有服务）
pnpm dev

# 只启动核心包开发
pnpm dev:core

# 只启动后端服务
pnpm dev:server

# 只启动前端服务
pnpm dev:web

# 构建所有包
pnpm build

# 只构建核心包
pnpm build:core

# 类型检查
pnpm typecheck

# 运行测试
pnpm test