Comprender un poco el host de MCP

Qué es MCP

MCP 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. 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.

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. 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, que se desarrolla en la organización mark3lab.

Su uso es muy sencillo.

1go install github.com/mark3labs/mcphost@latest

Tras 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 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.

1mcphost -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.

 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 veremos por separado las declaraciones internas de esa parte. Aun así, casi coinciden con sus nombres.

 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 los mcpClients y tools que se usan aquí, consulte el archivo correspondiente.
Para provider, usaremos el de ollama, así que consulte el archivo correspondiente.

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 combinación de fragmentos de el archivo correspondiente.

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.