GoSuda

Comprendiendo un poco el host de MCP

By snowmerak
views ...

¿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 a un LLM solicitar activamente acciones o recursos externos. Dado que MCP es literalmente solo un protocolo que envía solicitudes y recibe respuestas, el proceso y la ejecución deben ser realizados por el desarrollador.

Sobre el funcionamiento interno

Antes de explicar el funcionamiento interno, repasaremos Gemini Function Calling. Gemini Function Calling, al igual que MCP, permite que un LLM invoque acciones externas de forma proactiva. Entonces, uno podría preguntarse 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 es compatible con el uso del mismo esquema OpenAPI, por lo que se supuso que sus operaciones mutuas serían similares. Por lo tanto, se ha traído ya que se considera que la explicación de Gemini Function Calling es más detallada y útil.

FunctionCalling

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. "Envía el prompt del usuario junto con la(s) declaración(es) de función al modelo. Este analiza la solicitud y determina si una llamada a función sería útil. Si es así, responde con un objeto JSON estructurado."
  3. Gemini solicita la llamada a la función si es necesario.
    1. Si Gemini lo requiere, el llamante recibe el nombre y los parámetros para la llamada a la función.
    2. El llamante puede decidir si ejecutar o no.
      1. Si se va a ejecutar y devolver un valor válido.
      2. Si se va a devolver datos como si se hubiera llamado sin ejecutar.
      3. Si simplemente se va a 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 ver los resultados.
  5. Finalmente, se 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, lo que significa que la implementación de MCP por sí sola puede usarse en los tres lugares.

Ah, y hay una desventaja que todos comparten. Al final, el modelo es el que lo ejecuta, por lo que si el modelo que está utilizando no está en buen estado, puede haber un mal funcionamiento, como no llamar a una función, llamarla de forma extraña o 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 un 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 se recomiendan claude o qwen2.5 por defecto, por ahora yo recomiendo mistral-small.

1mcphost -m ollama:mistral-small

Sin embargo, si se ejecuta de esta manera, solo se puede usar para preguntas y respuestas en un entorno CLI. Por lo tanto, modificaremos el código de mcphost para que pueda operar de manera más programable.

Fork de mcphost

Como ya se ha comprobado, mcphost incluye la funcionalidad de extraer metadatos y llamar a funciones utilizando MCP. Por lo tanto, se necesitan las partes que llaman al LLM, las que manejan el servidor MCP y las que gestionan el historial de mensajes.

El Runner del siguiente paquete contiene estas partes:

 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 examinaremos la declaración interna de esa sección. Sin embargo, es casi literal.

 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, que utilizará 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 un compendio de partes del archivo correspondiente.

El contenido es aproximadamente el siguiente:

  1. Se envía la lista de herramientas junto con el prompt 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.

En conclusión

¿Ya terminó?

En realidad, no hay mucho más que decir. Este artículo fue escrito para ayudar a comprender cómo funciona el MCP Server. Espero que este artículo les haya sido de pequeña ayuda para comprender el funcionamiento del host de MCP.