Comprendiendo un poco el host MCP
¿Qué es MCP?
MCP es un protocolo desarrollado por Anthropic para Claude. MCP, acrónimo de Model Context Protocol, es un protocolo que permite a un LLM solicitar proactivamente acciones o recursos externos. Dado que MCP es literalmente solo un protocolo que proporciona solicitudes y respuestas, el proceso y la ejecución deben ser realizados por el desarrollador.
Sobre el funcionamiento interno
Antes de explicar el funcionamiento interno, abordaremos Gemini Function Calling. Gemini Function Calling, al igual que MCP, permite que un LLM inicie proactivamente acciones externas. Surge entonces la pregunta de por qué se ha traído a colación Function Calling. La razón por la que se ha traído es que Function Calling apareció antes que MCP y, al utilizar el mismo esquema OpenAPI, son compatibles, por lo que se presume que sus operaciones son similares. Por lo tanto, dado que la explicación de Gemini Function Calling es más detallada, se ha incluido aquí por su utilidad.
El flujo general es el siguiente:
- Se define una función.
- La definición de la función se envía a Gemini junto con el prompt.
- "Send user prompt along with the function declaration(s) to the model. It analyzes the request and determines if a function call would be helpful. If so, it responds with a structured JSON object."
- Gemini solicita la llamada a la función si es necesario.
- Si Gemini lo requiere, el llamador recibe el nombre y los parámetros para la llamada a la función.
- El llamador puede decidir si ejecuta o no.
- Si se ejecutará y devolverá un valor válido.
- Si se devolverán datos como si se hubiera llamado sin ejecutar.
- Si simplemente se ignorará.
- Gemini realiza y solicita acciones como llamar a múltiples funciones a la vez en el proceso anterior, o llamar a una función y luego llamar de nuevo después de revisar el resultado.
- Finalmente, termina cuando se obtiene una respuesta organizada.
Este flujo es generalmente consistente con MCP. Esto se explica de manera similar en el tutorial de MCP. Esto también es similar para las herramientas de Ollama.
Y, afortunadamente, estas tres herramientas (Ollama tools, MCP y Gemini Function Calling) comparten una estructura de esquema tan similar que la implementación de una sola de ellas (MCP) puede ser utilizada en las tres.
Ah, y hay un inconveniente que todas comparten. Al final, dado que el modelo es el que ejecuta, si el modelo que se utiliza no está en buenas condiciones, puede fallar al llamar a la función, llamarla de forma extraña o incluso lanzar un ataque DOS al servidor MCP.
Host MCP en Go
mcphost de mark3lab
En Go, existe mcphost, que está siendo desarrollado por la organización mark3lab.
Su uso es muy sencillo.
1go install github.com/mark3labs/mcphost@latest
Después de la instalación, cree el archivo $HOME/.mcp.json
y escriba lo siguiente:
1{
2 "mcpServers": {
3 "sqlite": {
4 "command": "uvx",
5 "args": [
6 "mcp-server-sqlite",
7 "--db-path",
8 "/tmp/foo.db"
9 ]
10 },
11 "filesystem": {
12 "command": "npx",
13 "args": [
14 "-y",
15 "@modelcontextprotocol/server-filesystem",
16 "/tmp"
17 ]
18 }
19 }
20}
Y luego ejecútelo con el modelo Ollama de la siguiente manera.
Por supuesto, si es necesario, primero descargue el modelo con ollama pull mistral-small
.
Aunque generalmente se recomiendan Claude o Qwen 2.5, por ahora recomiendo mistral-small.
1mcphost -m ollama:mistral-small
Sin embargo, si se ejecuta de esta manera, solo se puede utilizar en un entorno CLI para preguntas y respuestas.
Por lo tanto, modificaremos el código de mcphost
para que pueda operar de manera más programable.
Bifurcación de mcphost
Como ya se ha comprobado, mcphost
incluye la funcionalidad para extraer metadatos y llamar a funciones utilizando MCP. Por lo tanto, se necesitan las partes que llaman al LLM, manejan el servidor MCP y gestionan el historial de mensajes.
El Runner
de los siguientes paquetes es la parte que se ha tomado.
1package runner
2
3import (
4 "context"
5 "encoding/json"
6 "fmt"
7 "log"
8 "strings"
9 "time"
10
11 mcpclient "github.com/mark3labs/mcp-go/client"
12 "github.com/mark3labs/mcp-go/mcp"
13
14 "github.com/mark3labs/mcphost/pkg/history"
15 "github.com/mark3labs/mcphost/pkg/llm"
16)
17
18type Runner struct {
19 provider llm.Provider
20 mcpClients map[string]*mcpclient.StdioMCPClient
21 tools []llm.Tool
22
23 messages []history.HistoryMessage
24}
No analizaremos la declaración interna de esa sección. Sin embargo, es casi literal a su nombre.
1func NewRunner(systemPrompt string, provider llm.Provider, mcpClients map[string]*mcpclient.StdioMCPClient, tools []llm.Tool) *Runner {
2 return &Runner{
3 provider: provider,
4 mcpClients: mcpClients,
5 tools: tools,
6 messages: []history.HistoryMessage{
7 {
8 Role: "system",
9 Content: []history.ContentBlock{{
10 Type: "text",
11 Text: systemPrompt,
12 }},
13 },
14 },
15 }
16}
Para mcpClients
y tools
que se utilizarán aquí, consulte este archivo.
Para provider
, dado que utilizaremos el de Ollama, consulte este archivo.
El plato principal es el método Run
.
1func (r *Runner) Run(ctx context.Context, prompt string) (string, error) {
2 if len(prompt) != 0 {
3 r.messages = append(r.messages, history.HistoryMessage{
4 Role: "user",
5 Content: []history.ContentBlock{{
6 Type: "text",
7 Text: prompt,
8 }},
9 })
10 }
11
12 llmMessages := make([]llm.Message, len(r.messages))
13 for i := range r.messages {
14 llmMessages[i] = &r.messages[i]
15 }
16
17 const initialBackoff = 1 * time.Second
18 const maxRetries int = 5
19 const maxBackoff = 30 * time.Second
20
21 var message llm.Message
22 var err error
23 backoff := initialBackoff
24 retries := 0
25 for {
26 message, err = r.provider.CreateMessage(
27 context.Background(),
28 prompt,
29 llmMessages,
30 r.tools,
31 )
32 if err != nil {
33 if strings.Contains(err.Error(), "overloaded_error") {
34 if retries >= maxRetries {
35 return "", fmt.Errorf(
36 "claude is currently overloaded. please wait a few minutes and try again",
37 )
38 }
39
40 time.Sleep(backoff)
41 backoff *= 2
42 if backoff > maxBackoff {
43 backoff = maxBackoff
44 }
45 retries++
46 continue
47 }
48
49 return "", err
50 }
51
52 break
53 }
54
55 var messageContent []history.ContentBlock
56
57 var toolResults []history.ContentBlock
58 messageContent = []history.ContentBlock{}
59
60 if message.GetContent() != "" {
61 messageContent = append(messageContent, history.ContentBlock{
62 Type: "text",
63 Text: message.GetContent(),
64 })
65 }
66
67 for _, toolCall := range message.GetToolCalls() {
68 input, _ := json.Marshal(toolCall.GetArguments())
69 messageContent = append(messageContent, history.ContentBlock{
70 Type: "tool_use",
71 ID: toolCall.GetID(),
72 Name: toolCall.GetName(),
73 Input: input,
74 })
75
76 parts := strings.Split(toolCall.GetName(), "__")
77
78 serverName, toolName := parts[0], parts[1]
79 mcpClient, ok := r.mcpClients[serverName]
80 if !ok {
81 continue
82 }
83
84 var toolArgs map[string]interface{}
85 if err := json.Unmarshal(input, &toolArgs); err != nil {
86 continue
87 }
88
89 var toolResultPtr *mcp.CallToolResult
90 req := mcp.CallToolRequest{}
91 req.Params.Name = toolName
92 req.Params.Arguments = toolArgs
93 toolResultPtr, err = mcpClient.CallTool(
94 context.Background(),
95 req,
96 )
97
98 if err != nil {
99 errMsg := fmt.Sprintf(
100 "Error calling tool %s: %v",
101 toolName,
102 err,
103 )
104 log.Printf("Error calling tool %s: %v", toolName, err)
105
106 toolResults = append(toolResults, history.ContentBlock{
107 Type: "tool_result",
108 ToolUseID: toolCall.GetID(),
109 Content: []history.ContentBlock{{
110 Type: "text",
111 Text: errMsg,
112 }},
113 })
114
115 continue
116 }
117
118 toolResult := *toolResultPtr
119
120 if toolResult.Content != nil {
121 resultBlock := history.ContentBlock{
122 Type: "tool_result",
123 ToolUseID: toolCall.GetID(),
124 Content: toolResult.Content,
125 }
126
127 var resultText string
128 for _, item := range toolResult.Content {
129 if contentMap, ok := item.(map[string]interface{}); ok {
130 if text, ok := contentMap["text"]; ok {
131 resultText += fmt.Sprintf("%v ", text)
132 }
133 }
134 }
135
136 resultBlock.Text = strings.TrimSpace(resultText)
137
138 toolResults = append(toolResults, resultBlock)
139 }
140 }
141
142 r.messages = append(r.messages, history.HistoryMessage{
143 Role: message.GetRole(),
144 Content: messageContent,
145 })
146
147 if len(toolResults) > 0 {
148 r.messages = append(r.messages, history.HistoryMessage{
149 Role: "user",
150 Content: toolResults,
151 })
152
153 return r.Run(ctx, "")
154 }
155
156 return message.GetContent(), nil
157}
El código en sí es una mezcla de algunas partes del código de este archivo.
El contenido es aproximadamente el siguiente:
- Se envía el prompt junto con la lista de herramientas para solicitar la ejecución o la generación de una respuesta.
- Si se genera una respuesta, la recursión se detiene y se devuelve.
- Si el LLM deja una solicitud de ejecución de herramienta, el host llama al MCP Server.
- La respuesta se añade al historial y se vuelve al paso 1.
Para concluir
¿Ya terminamos?
En realidad, no hay mucho más que decir. Este artículo se ha escrito para ayudar a comprender cómo funciona un MCP Server de forma general. Espero que este artículo les haya sido de alguna ayuda, aunque sea pequeña, para comprender el funcionamiento del host MCP.