MCP 入门指南

"mcpServers": {
  "fetch": {
    "command": "uvx",
    "args": ["mcp-server-fetch"]
  }
}

"mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-brave-search"
      ],
      "env": {
        "BRAVE_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }

"mcpServers": {
	"fetch": {
		"command": "uvx",
		"args": [
			"mcp-server-fetch"
		]
	}
}

"mcpServers": {
	"puppeteer": {
		"command": "npx",
		"args": [
			"-y",
			"@modelcontextprotocol/server-puppeteer"
		]
	}
}

import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"

const tools = await mcpClient.request({
	// 获取 tools 列表
    method: "tools/list"
  }, ListToolsResultSchema);

const response = await this.anthropicClient.messages.create({
  messages: [
    {
      role: 'user',
      content: 'What is the weather in Shanghai',
    },
  ],
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 8192,
  tools: this.tools, // 传递 tools
});

import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"

const tools = await mcpClient.request({
	// 获取 tools 列表
    method: "tools/list"
  }, ListToolsResultSchema);


const compatibleToolFuncForOpenAI = (tools?.tools ?? []).map(tool => ({
    type: 'function',
    function: {
      name: tool.name,
      description: tool.description,
      parameters: tool.inputSchema,
    },
  }))

let completion = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    store: true,
    tools: compatibleTools,
    messages: [{
	    role: 'user',
	    content: 'What is the weather in Shanghai' 
	}],
});

export const getSystemPrompt = (tools) => `TOOL USE

You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.

# Tool Use Formatting

Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:

<tool*name>
<parameter1_name>value1</parameter1_name>
<parameter2_name>value2</parameter2_name>
...
</tool_name>

For example:

<use_mcp_tool>
<server_name>weather-server</server_name>
<tool_name>get_forecast</tool_name>
<arguments>
{
 \"city\": \"San Francisco\",
 \"days\": 5
}
</arguments>
</use_mcp_tool>

Always adhere to this format for the tool use to ensure proper parsing and execution.

# Tools

# Tool Use Examples

## Example 1: Requesting to use an MCP tool

<use_mcp_tool>
<server_name>weather-server</server_name>
<tool_name>get_forecast</tool_name>
<arguments>
{
 \"city\": \"San Francisco\",
 \"days\": 5
}
</arguments>
</use_mcp_tool>

====

MCP SERVERS

The Model Context Protocol (MCP) enables communication between the system and locally running MCP servers that provide additional tools and resources to extend your capabilities.

# Connected MCP Servers

When a server is connected, you can use the server's tools via the \`use_mcp_tool\` tool, and access the server's resources via the \`access_mcp_resource\` tool.

## weather (\`node /Users/nazha/nazha-all/mcp-weather/build/index.js\`)

### Available Tools

${tools.map(tool => `- ${tool.name}: ${tool.description}\nInput Schema: ${JSON.stringify(tool.inputSchema)}`).join('\n')}

# MCP Servers Are Not Always Necessary

The user may not always request the use or creation of MCP servers. Instead, they might provide tasks that can be completed with existing tools. While using the MCP SDK to extend your capabilities can be useful, it's important to understand that this is just one specialized type of task you can accomplish. You should only implement MCP servers when the user explicitly requests it (e.g., \"add a tool that...\").

Remember: The MCP documentation and example provided above are to help you understand and work with existing MCP servers or create new ones when requested by the user. You already have access to tools and capabilities that can be used to accomplish a wide range of tasks

====
`

I can get the weather forecast for San Francisco. Please hold on for a moment while I retrieve that information. 

I'll use the location's latitude and longitude to get the forecast. San Francisco's coordinates are approximately 37.7749° N, 122.4194° W. 

Let me get the forecast for you. 

<use_mcp_tool>
<server_name>weather-server</server_name>
<tool_name>get-forecast</tool_name>
<arguments>
{
 "latitude": 37.7749,
 "longitude": -122.4194
}
</arguments>
</use_mcp_tool>

// Wait for the LLM to respond with a tool use
if (content.type === 'tool_use') {
	const toolName = content.name;
	const toolArgs = content.input;
	// Call the tool handler on the MCP Server
	const toolResult = await mcpClient.request(
		{
			method: 'tools/call',
			params: {
				name: toolName,
				arguments: toolArgs,
			},
		},
		CallToolResultSchema,
	);

const completion = await openai.chat.completions.create({
	model: 'gpt-4o-mini',
	store: true,
	messages: [{ role: 'user', content: prompt }, { role: 'user', content: toolResponse.content?.[0]?.text }],
});