GoSuda

En kort forståelse av 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, som er en protokoll som gjør det mulig for en LLM å aktivt be om eksterne handlinger eller ressurser. Siden MCP bokstavelig talt bare er en protokoll som gir forespørsler og svar, må prosessen og utførelsen gjøres av utvikleren.

Om intern funksjon

Før vi forklarer den interne funksjonen, vil vi se på Gemini Function Calling. Gemini Function Calling, akkurat som MCP, lar LLM proaktivt kalle eksterne funksjoner. Du lurer kanskje på hvorfor Function Calling ble nevnt. Grunnen til at det ble nevnt er at Function Calling kom før MCP, og siden begge bruker OpenAPI-skjemaet, er de kompatible, og det ble antatt at deres gjensidige funksjon ville være lik. Derfor ble det nevnt, da forklaringen av Gemini Function Calling er mer detaljert og forventes å være nyttig.

FunctionCalling

Den generelle 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 om nødvendig.
    1. Hvis Gemini trenger det, mottar den som kaller navnet og parameterne for funksjonskallet.
    2. Den som kaller kan bestemme om den skal utføre eller ikke.
      1. Om den skal kalle og returnere en gyldig verdi
      2. Om den skal returnere data som om den ble kalt, uten å kalle
      3. Om den bare skal ignorere det
  4. Gemini utfører og ber om handlinger som å kalle flere funksjoner samtidig i prosessen ovenfor, eller kalle igjen etter å ha sett resultatet av et funksjonskall.
  5. Til slutt, når et ryddig svar er gitt, avsluttes prosessen.

Denne flyten er generelt i tråd med MCP. Dette er også beskrevet på en lignende måte i MCPs veiledning. Dette gjelder også for Ollama tools.

Og heldigvis deler disse tre verktøyene – Ollama tools, MCP og Gemini Function Calling – en lignende skjemastruktur, slik at man kan implementere MCP én gang og bruke den i alle tre.

Å, og det er en ulempe som alle deler. Fordi det er modellen som utfører det, hvis modellen du bruker er i dårlig stand, kan den unnlate å kalle funksjoner, kalle dem på en merkelig måte, eller utføre feilaktige operasjoner som å utføre en DOS-angrep på MCP-serveren.

MCP-vert i Go

mark3lab's mcphost

I Go finnes det mcphost som utvikles av organisasjonen mark3lab.

Bruken er svært enkel.

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

Etter installasjon, opprett filen $HOME/.mcp.json og skriv inn følgende:

 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 den med en Ollama-modell som følger. Selvfølgelig, hvis nødvendig, kan du laste ned modellen med ollama pull mistral-small først.

Selv om claude eller qwen2.5 anbefales som standard, anbefaler jeg for øyeblikket mistral-small.

1mcphost -m ollama:mistral-small

Men hvis den kjøres på denne måten, kan den bare brukes i CLI-miljøet som en spørsmål-og-svar-dialog. Derfor vil vi endre koden til denne mcphost for å gjøre den mer programmerbar.

Forking av mcphost

Som allerede bekreftet, inkluderer mcphost funksjonalitet for å trekke ut metadata og kalle funksjoner ved hjelp av MCP. Derfor er det behov for deler som kaller LLM, håndterer MCP-serveren og administrerer meldingshistorikken.

Runner i den tilsvarende pakken er det som er hentet inn.

 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}

Vi vil ikke se på den interne deklarasjonen av den tilsvarende delen separat. Men den er nesten bokstavelig talt som navnet tilsier.

 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 skal brukes her, vennligst se denne filen. For provider, som vil bruke Ollamas, vennligst se denne filen.

Hovedretten er Run-metoden.

  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}

Selve koden er sammensatt av deler fra denne filen.

Innholdet er omtrent som følger:

  1. Send en liste over verktøy sammen med prompten for å be om utførelse eller generering av et svar.
  2. Hvis et svar genereres, stopp rekursjonen og returner det.
  3. Hvis LLM etterlater en forespørsel om å utføre et verktøy, kaller verten MCP Server.
  4. Legg til svaret i historikken og gå tilbake til trinn 1.

Til slutt

Allerede ferdig?

Det er egentlig ikke så mye å si. Denne artikkelen er skrevet for å hjelpe deg med å forstå hvordan MCP Server fungerer. Jeg håper denne artikkelen har vært til litt hjelp for deg i forståelsen av MCP host.