--- id: a1fad13de24c90924cfa9e25e9f986cb author: snowmerak title: Comprender un poco el host de MCP description: Este texto tiene como objetivo facilitar la comprensión del protocolo MCP de Anthropic y del host MCP (mcphost) implementado en Go. language: es date: 2025-04-08T00:59:42.416582136Z path: /blog/posts/a-little-understanding-of-mcp-host-zb952aae0 category: ai --- ## Qué es MCP [MCP](https://modelcontextprotocol.io/introduction) es un protocolo desarrollado por Anthropic para Claude. MCP es la abreviatura de Model Context Protocol, y es un protocolo que permite que los LLM soliciten de forma proactiva acciones o recursos externos. Dado que MCP es literalmente un protocolo que únicamente proporciona solicitudes y respuestas, el proceso y la ejecución deben ser implementados por el desarrollador. ### Acerca de su funcionamiento interno Antes de explicar el funcionamiento interno, quisiera detenerme brevemente en [Gemini Function Calling](https://ai.google.dev/gemini-api/docs/function-calling). Gemini Function Calling, al igual que MCP, permite que el LLM invoque de forma activa operaciones externas. Probablemente se preguntará por qué he traído Function Calling. La razón es que Function Calling apareció antes que MCP y, además, es compatible en cuanto a que ambos utilizan esquemas de OpenAPI, por lo que supuse que su comportamiento sería similar. Dado que la explicación de Gemini Function Calling es comparativamente más detallada, consideré que sería de ayuda incluirla. ![FunctionCalling](/assets/images/mcp_with_csharp/function-calling-overview.png) El flujo general es el siguiente. 1. Se define la función. 2. Se envía la definición de la función a Gemini junto con el prompt. 1. "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." 3. Si Gemini lo considera necesario, solicita una llamada a función. 1. Si Gemini lo considera necesario, el llamador recibe el nombre y los parámetros para la llamada a la función. 2. El llamador puede decidir si ejecuta o no la llamada. 1. Ejecutar la llamada y devolver un valor legítimo. 2. No ejecutar la llamada y devolver datos como si la hubiera ejecutado. 3. Simplemente ignorarla. 4. Gemini puede realizar y solicitar, en el proceso anterior, varias funciones a la vez, o bien llamar de nuevo tras observar el resultado de una función. 5. Cuando se obtiene finalmente una respuesta ordenada, el proceso termina. Este flujo coincide, en términos generales, con MCP. También se describe de forma similar en el [tutorial de MCP](https://modelcontextprotocol.io/tutorials/building-mcp-with-llms). Ollama tools también funciona de manera parecida. Y, afortunadamente, estas tres herramientas, ollama tools, MCP y Gemini Function Calling, comparten prácticamente la misma estructura de esquemas, de modo que implementando únicamente MCP es posible utilizarlo en las tres. Ah, y también existe una desventaja compartida por todas. Como es el modelo quien ejecuta las llamadas, si el modelo que utiliza se encuentra en mal estado, puede no llamar a la función, llamarla de forma incorrecta o incluso provocar comportamientos anómalos como lanzar un DOS contra el servidor MCP. ## Host MCP en Go ### mcphost de mark3lab En Go existe [mcphost](https://github.com/mark3labs/mcphost), que se desarrolla en la organización mark3lab. Su uso es muy sencillo. ```sh go install github.com/mark3labs/mcphost@latest ``` Tras la instalación, cree el archivo `$HOME/.mcp.json` y escriba lo siguiente. ```json { "mcpServers": { "sqlite": { "command": "uvx", "args": [ "mcp-server-sqlite", "--db-path", "/tmp/foo.db" ] }, "filesystem": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-filesystem", "/tmp" ] } } } ``` Y luego ejecútelo con un modelo de ollama de la siguiente manera. Por supuesto, si es necesario, antes descargue el modelo con `ollama pull mistral-small`. > En general se recomiendan Claude o qwen2.5, pero personalmente, por ahora, recomiendo mistral-small. ```sh mcphost -m ollama:mistral-small ``` Sin embargo, al ejecutarlo de esta forma, solo puede utilizarse en un entorno CLI en modo de preguntas y respuestas. Por ello, modificaremos el código de este `mcphost` para que pueda operar de forma más programable. ### Bifurcación de mcphost Como ya se ha comprobado, `mcphost` incluye la funcionalidad de extraer metadatos y llamar funciones mediante MCP. Por tanto, se necesitan la parte que llama al LLM, la parte que gestiona los servidores MCP y la parte que administra el historial de mensajes. La parte correspondiente se ha extraído en el `Runner` del siguiente paquete. ```go package runner import ( "context" "encoding/json" "fmt" "log" "strings" "time" mcpclient "github.com/mark3labs/mcp-go/client" "github.com/mark3labs/mcp-go/mcp" "github.com/mark3labs/mcphost/pkg/history" "github.com/mark3labs/mcphost/pkg/llm" ) type Runner struct { provider llm.Provider mcpClients map[string]*mcpclient.StdioMCPClient tools []llm.Tool messages []history.HistoryMessage } ``` No veremos por separado las declaraciones internas de esa parte. Aun así, casi coinciden con sus nombres. ```go func NewRunner(systemPrompt string, provider llm.Provider, mcpClients map[string]*mcpclient.StdioMCPClient, tools []llm.Tool) *Runner { return &Runner{ provider: provider, mcpClients: mcpClients, tools: tools, messages: []history.HistoryMessage{ { Role: "system", Content: []history.ContentBlock{{ Type: "text", Text: systemPrompt, }}, }, }, } } ``` Para los `mcpClients` y `tools` que se usan aquí, consulte [el archivo correspondiente](https://github.com/snowmerak/mcphost/blob/main/internal/runner/from.go). Para `provider`, usaremos el de ollama, así que consulte [el archivo correspondiente](https://github.com/snowmerak/mcphost/blob/main/pkg/llm/ollama/provider.go). El plato principal es el método `Run`. ```go func (r *Runner) Run(ctx context.Context, prompt string) (string, error) { if len(prompt) != 0 { r.messages = append(r.messages, history.HistoryMessage{ Role: "user", Content: []history.ContentBlock{{ Type: "text", Text: prompt, }}, }) } llmMessages := make([]llm.Message, len(r.messages)) for i := range r.messages { llmMessages[i] = &r.messages[i] } const initialBackoff = 1 * time.Second const maxRetries int = 5 const maxBackoff = 30 * time.Second var message llm.Message var err error backoff := initialBackoff retries := 0 for { message, err = r.provider.CreateMessage( context.Background(), prompt, llmMessages, r.tools, ) if err != nil { if strings.Contains(err.Error(), "overloaded_error") { if retries >= maxRetries { return "", fmt.Errorf( "claude is currently overloaded. please wait a few minutes and try again", ) } time.Sleep(backoff) backoff *= 2 if backoff > maxBackoff { backoff = maxBackoff } retries++ continue } return "", err } break } var messageContent []history.ContentBlock var toolResults []history.ContentBlock messageContent = []history.ContentBlock{} if message.GetContent() != "" { messageContent = append(messageContent, history.ContentBlock{ Type: "text", Text: message.GetContent(), }) } for _, toolCall := range message.GetToolCalls() { input, _ := json.Marshal(toolCall.GetArguments()) messageContent = append(messageContent, history.ContentBlock{ Type: "tool_use", ID: toolCall.GetID(), Name: toolCall.GetName(), Input: input, }) parts := strings.Split(toolCall.GetName(), "__") serverName, toolName := parts[0], parts[1] mcpClient, ok := r.mcpClients[serverName] if !ok { continue } var toolArgs map[string]interface{} if err := json.Unmarshal(input, &toolArgs); err != nil { continue } var toolResultPtr *mcp.CallToolResult req := mcp.CallToolRequest{} req.Params.Name = toolName req.Params.Arguments = toolArgs toolResultPtr, err = mcpClient.CallTool( context.Background(), req, ) if err != nil { errMsg := fmt.Sprintf( "Error calling tool %s: %v", toolName, err, ) log.Printf("Error calling tool %s: %v", toolName, err) toolResults = append(toolResults, history.ContentBlock{ Type: "tool_result", ToolUseID: toolCall.GetID(), Content: []history.ContentBlock{{ Type: "text", Text: errMsg, }}, }) continue } toolResult := *toolResultPtr if toolResult.Content != nil { resultBlock := history.ContentBlock{ Type: "tool_result", ToolUseID: toolCall.GetID(), Content: toolResult.Content, } var resultText string for _, item := range toolResult.Content { if contentMap, ok := item.(map[string]interface{}); ok { if text, ok := contentMap["text"]; ok { resultText += fmt.Sprintf("%v ", text) } } } resultBlock.Text = strings.TrimSpace(resultText) toolResults = append(toolResults, resultBlock) } } r.messages = append(r.messages, history.HistoryMessage{ Role: message.GetRole(), Content: messageContent, }) if len(toolResults) > 0 { r.messages = append(r.messages, history.HistoryMessage{ Role: "user", Content: toolResults, }) return r.Run(ctx, "") } return message.GetContent(), nil } ``` El código en sí es una combinación de fragmentos de [el archivo correspondiente](https://github.com/snowmerak/mcphost/blob/main/cmd/mcp.go). El contenido, en líneas generales, es el siguiente. 1. Se envía la lista de herramientas junto con el prompt para solicitar si se debe ejecutar algo o generar una respuesta. 2. Cuando se genera una respuesta, se detiene la recursión y se devuelve. 3. Si el LLM deja una solicitud de ejecución de herramienta, el host llama al servidor MCP. 4. Se añade la respuesta al historial y se vuelve al paso 1. ## Para terminar > ¿Ya terminó? En realidad, no tengo tanto que decir. Este artículo se escribió principalmente para ayudar a comprender, de forma general, cómo funciona un servidor MCP. Espero que este texto le haya servido, aunque sea un poco, para entender el funcionamiento de un host MCP.