GoSuda

Essayer de comprendre un peu l'hôte MCP

By snowmerak views ...

Qu'est-ce que MCP

MCP est un protocole développé par Anthropic pour Claude. MCP est l'abréviation de Model Context Protocol, un protocole qui permet aux LLM de demander activement des actions ou des ressources à l'extérieur. Comme MCP n'est littéralement qu'un protocole de requêtes et de réponses, le processus et l'exécution doivent être implémentés par le développeur.

À propos du fonctionnement interne

Avant d'expliquer le fonctionnement interne, je voudrais évoquer Gemini Function Calling. Gemini Function Calling permet également, comme MCP, au LLM d'invoquer de manière proactive des actions externes. On pourrait alors se demander pourquoi avoir introduit Function Calling. La raison est que Function Calling est apparu avant MCP et qu'il utilise de manière identique le schéma OpenAPI, ce qui le rend compatible; j'ai donc supposé que son fonctionnement serait similaire. Par conséquent, comme la documentation de Gemini Function Calling est relativement plus détaillée, j'ai jugé utile de l'inclure.

FunctionCalling

Le flux global se présente ainsi.

  1. On définit une fonction.
  2. On envoie à Gemini la définition de la fonction accompagnée du 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 demande un appel de fonction si nécessaire.
    1. Si Gemini le juge nécessaire, l'appelant reçoit le nom et les paramètres de l'appel de fonction.
    2. L'appelant peut décider d'exécuter ou non l'appel.
      1. Effectuer l'appel et renvoyer une valeur légitime
      2. Ne pas effectuer l'appel et renvoyer des données comme si celui-ci avait été effectué
      3. Simplement l'ignorer
  4. Gemini effectue et demande plusieurs appels de fonctions en une seule fois, ou appelle à nouveau une fonction après avoir examiné le résultat d'un appel précédent.
  5. Lorsqu'une réponse structurée est finalement produite, le processus se termine.

Ce flux est globalement cohérent avec MCP. Il est d'ailleurs décrit de manière similaire dans le tutoriel MCP. Il en va de même pour ollama tools.

Et, heureusement, ces trois outils, ollama tools, MCP et Gemini Function Calling, partagent presque la même structure de schéma; ainsi, en n'implémentant que MCP, on peut l'utiliser dans les trois contextes.

Ah, et il existe un inconvénient commun à tous. Comme c'est le modèle qui exécute ces appels, si le modèle que vous utilisez est de mauvaise qualité, il peut ne pas appeler la fonction, l'appeler de manière incorrecte, ou encore envoyer une attaque DoS au serveur MCP, entre autres dysfonctionnements.

Hôte MCP en Go

mcphost de mark3lab

En Go, il existe mcphost, développé par l'organisation mark3lab.

Son utilisation est très simple.

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

Après l'installation, créez le fichier $HOME/.mcp.json et rédigez-le comme suit.

 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}

Ensuite, exécutez-le avec le modèle ollama comme suit.
Bien entendu, si nécessaire, téléchargez d'abord le modèle avec ollama pull mistral-small.

En règle générale, Claude ou qwen2.5 sont recommandés, mais pour le moment, je recommande mistral-small.

1mcphost -m ollama:mistral-small

Cependant, avec cette exécution, vous ne pouvez l'utiliser qu'en mode questions-réponses dans un environnement CLI.
C'est pourquoi nous allons modifier le code de ce mcphost afin de le rendre plus programmable.

Fork de mcphost

Comme nous l'avons vu, mcphost intègre des fonctionnalités qui utilisent MCP pour extraire des métadonnées et appeler des fonctions. Il faut donc une partie qui appelle le LLM, une partie qui gère le serveur MCP et une partie qui gère l'historique des messages.

Le Runner du package suivant reprend ces parties.

 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}

Je ne m'attarderai pas sur les déclarations internes de cette partie. Elles correspondent presque exactement à leurs noms.

 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}

Pour les mcpClients et tools utilisés ici, veuillez consulter ce fichier.
Pour le provider, nous utiliserons celui d'ollama; veuillez consulter ce fichier.

Le plat principal est la méthode 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}

Le code lui-même a été assemblé à partir d'une partie du code de ce fichier.

Le contenu peut se résumer ainsi.

  1. On envoie la liste des outils avec le prompt pour demander soit une exécution, soit la génération d'une réponse.
  2. Lorsqu'une réponse est générée, on arrête la récursion et on la renvoie.
  3. Si le LLM demande l'exécution d'un outil, l'hôte appelle le serveur MCP.
  4. On ajoute le résultat à l'historique, puis on revient à l'étape 1.

Pour conclure

Déjà la fin?

En réalité, je n'ai pas grand-chose de plus à dire. Cet article a été rédigé pour vous aider à comprendre, en gros, le fonctionnement d'un serveur MCP. J'espère qu'il vous a été utile, même modestement, pour comprendre le fonctionnement d'un hôte MCP.