GoSuda

Comprendiendo un poco el host MCP

By snowmerak
views ...

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

FunctionCalling

El flujo general es el siguiente:

  1. Se define una función.
  2. La definición de la función se envía 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. Gemini solicita la llamada a la función si es necesario.
    1. Si Gemini lo requiere, 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.
      1. Si se ejecutará y devolverá un valor válido.
      2. Si se devolverán datos como si se hubiera llamado sin ejecutar.
      3. Si simplemente se ignorará.
  4. 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.
  5. 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:

  1. Se envía el prompt junto con la lista de herramientas para solicitar la ejecución o la generación de una respuesta.
  2. Si se genera una respuesta, la recursión se detiene y se devuelve.
  3. Si el LLM deja una solicitud de ejecución de herramienta, el host llama al MCP Server.
  4. 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.