GoSuda

Litt om å forstå MCP host

By snowmerak views ...

Hva er MCP

MCP er en protokoll utviklet av Anthropic for Claude. MCP er en forkortelse for Model Context Protocol, og er en protokoll som gjør det mulig for en LLM å aktivt be om handlinger eller ressurser fra eksterne systemer. Siden MCP i bokstavelig forstand bare er en protokoll for å sende forespørsler og motta svar, må utvikleren selv håndtere prosessen og utførelsen.

Om den interne virkemåten

Før jeg forklarer den interne virkemåten, vil jeg kort gjennomgå Gemini Function Calling. Gemini Function Calling gjør det også mulig for en LLM å aktivt kalle eksterne funksjoner, på samme måte som MCP. Du vil kanskje lure på hvorfor Function Calling tas med her. Grunnen er at Function Calling kom før MCP, og at begge bruker OpenAPI-skjemaer, noe som gjør dem kompatible; derfor antok jeg at deres interne virkemåte ligner hverandre. Ettersom forklaringen av Gemini Function Calling er relativt detaljert, vil den sannsynligvis være nyttig, og derfor er den tatt med.

FunctionCalling

Den overordnede flyten er som følger.

  1. Definer funksjonen.
  2. Send funksjonsdefinisjonen til Gemini sammen med prompten.
    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 ber om et funksjonskall hvis det er nødvendig.
    1. Dersom Gemini trenger et funksjonskall, mottar kalleren navnet og parameterne for kallet.
    2. Kalleren kan selv velge om den vil utføre kallet eller ikke.
      1. Utføre kallet og returnere en gyldig verdi
      2. Returnere data som om kallet var utført, uten å faktisk utføre det
      3. Ignorere det
  4. I løpet av denne prosessen kan Gemini be om flere funksjonskall samtidig, eller utføre og be om flere kall etter å ha sett resultatet av forrige kall.
  5. Når et ryddig svar foreligger, avsluttes prosessen.

Denne flyten samsvarer i hovedsak med MCP. Det er også forklart på lignende måte i MCPs veiledning. Ollama tools fungerer også på omtrent samme måte.

Og heldigvis deler disse tre verktøyene, Ollama tools, MCP og Gemini Function Calling, nesten samme skjemastruktur, slik at man kan bruke alle tre ved å implementere bare MCP.

Og så er det en ulempe som alle deler. Siden det er modellen som faktisk utfører kallene, kan en modell i dårlig forfatning unnlate å kalle funksjoner, kalle dem feil, eller til og med overbelaste MCP-serveren med DoS-lignende forespørsler.

MCP-vert i Go

mark3lab sin mcphost

I Go finnes mcphost, som utvikles av organisasjonen mark3lab.

Bruken er svært enkel.

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

Etter installasjonen oppretter du filen $HOME/.mcp.json og skriver følgende i den.

 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}

Deretter kjører du det med en Ollama-modell som følger.
Før det, om nødvendig, hent modellen med ollama pull mistral-small.

Generelt anbefales Claude eller qwen2.5, men foreløpig anbefaler jeg mistral-small.

1mcphost -m ollama:mistral-small

Når du kjører det på denne måten, kan du bare bruke det som spørsmål og svar i et CLI-miljø.
Derfor skal vi endre koden i mcphost slik at den kan fungere mer programmerbart.

Fork av mcphost

Som vi allerede har sett, inneholder mcphost funksjonalitet for å hente metadata og kalle funksjoner via MCP. Derfor trenger vi en del som kaller LLM, en del som håndterer MCP-serveren, og en del som administrerer meldingshistorikken.

Delen som dekker dette er Runner i følgende pakke.

 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}

Den interne deklarasjonen av denne delen går jeg ikke gjennom separat. Navnene er imidlertid nesten selvforklarende.

 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}

For mcpClients og tools som brukes her, se denne filen.
For provider bruker vi Ollamas variant, så se denne filen.

Hovedretten er metoden 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}

Koden er satt sammen av deler fra denne filen.

Innholdet kan oppsummeres slik:

  1. Send prompten sammen med verktøylisten og be om enten en vurdering av kjøring eller et generert svar.
  2. Når et svar er generert, stopper rekursjonen og svaret returneres.
  3. Dersom LLM legger igjen en forespørsel om verktøykjøring, kaller verten MCP-serveren.
  4. Legg resultatet til i historikken og gå tilbake til punkt 1.

Til slutt

Allerede slutt?

Egentlig er det ikke så mye mer å si. Teksten er skrevet for å gi en forståelse av hvordan en MCP-server fungerer. Jeg håper den har bidratt, om så bare litt, til å forstå hvordan en MCP-vert fungerer.