GoSuda

Förstå MCP host lite bättre

By snowmerak
views ...

Vad är MCP?

MCP är ett protokoll som utvecklats av Anthropic för Claude. MCP är en förkortning för Model Context Protocol och är ett protokoll som gör det möjligt för LLM att aktivt begära externa operationer eller resurser. Eftersom MCP bokstavligen bara är ett protokoll för att skicka förfrågningar och få svar, måste utvecklaren hantera processen och exekveringen.

Om intern funktion

Innan vi förklarar den interna funktionen, låt oss kortfattat gå igenom Gemini Function Calling. Precis som MCP tillåter Gemini Function Calling LLM att proaktivt anropa externa operationer. Du kanske undrar varför Function Calling togs upp. Anledningen till att det togs upp är att Function Calling kom före MCP och är kompatibelt eftersom båda använder OpenAPI-schemat, så vi antog att deras interaktioner skulle vara likartade. Därför togs det upp eftersom Gemini Function Callings förklaring är mer detaljerad och kan vara till hjälp.

FunctionCalling

Det övergripande flödet är följande:

  1. Definiera funktionen.
  2. Skicka funktionsdefinitionen till Gemini tillsammans med prompten.
    1. "Skicka användarprompten tillsammans med funktionsdeklarationen/deklarationerna till modellen. Den analyserar begäran och avgör om ett funktionsanrop skulle vara till hjälp. Om så är fallet svarar den med ett strukturerat JSON-objekt."
  3. Gemini begär ett funktionsanrop om det behövs.
    1. Om Gemini behöver det, får anroparen namnet och parametrarna för funktionsanropet.
    2. Anroparen kan bestämma om den ska exekvera eller inte.
      1. Om den ska anropa och returnera ett giltigt värde
      2. Om den ska returnera data som om den hade anropat, utan att faktiskt anropa
      3. Om den bara ska ignorera det
  4. Gemini utför och begär operationer som att anropa flera funktioner samtidigt i ovanstående process, eller anropa en funktion och sedan anropa igen baserat på resultatet.
  5. Slutligen avslutas det när ett välstrukturerat svar erhålls.

Detta flöde är generellt sett i linje med MCP. Detta förklaras också på ett liknande sätt i MCP:s handledning. Detta liknar även ollama tools.

Och lyckligtvis delar dessa tre verktyg, ollama tools, MCP och Gemini Function Calling, en så liknande schemastruktur att det räcker med att implementera MCP en gång för att kunna använda det på alla tre platser.

Åh, och det finns en gemensam nackdel. Eftersom det i slutändan är modellen som exekverar det, om modellen du använder är i dåligt skick, kan den misslyckas med att anropa funktioner, anropa dem på ett konstigt sätt, eller utföra felaktiga operationer som att utföra en DOS-attack mot MCP-servern.

MCP-värd i Go

mark3lab's mcphost

I Go finns mcphost som utvecklas av organisationen mark3lab.

Användningen är mycket enkel.

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

Efter installationen, skapa filen $HOME/.mcp.json och skriv följande:

 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}

Och kör den sedan med en ollama-modell enligt följande. Naturligtvis, om det behövs, hämta modellen med ollama pull mistral-small först.

Grundläggande rekommenderas Claude eller Qwen2.5, men för närvarande rekommenderar jag mistral-small.

1mcphost -m ollama:mistral-small

Men om du kör den på detta sätt kan den endast användas för frågor och svar i en CLI-miljö. Därför kommer vi att modifiera koden för denna mcphost för att göra den mer programmerbar.

mcphost Fork

Som redan konstaterats innehåller mcphost funktioner för att extrahera metadata och anropa funktioner med hjälp av MCP. Därför behövs delar för att anropa LLM, hantera MCP-servern och hantera meddelandehistorik.

Runner i följande paket är den del som hämtats.

 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 kommer inte att titta på den interna deklarationen av denna del separat. Men den är nästan exakt som namnet antyder.

 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}

För mcpClients och tools som används här, se denna fil. För provider, som kommer att använda ollamas, se denna fil.

Huvudrätten är 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.HistoryBlock{ // Ändrad från history.HistoryMessage till history.HistoryBlock
143		Role:    message.GetRole(),
144		Content: messageContent,
145	})
146
147	if len(toolResults) > 0 {
148		r.messages = append(r.messages, history.HistoryBlock{ // Ändrad från history.HistoryMessage till history.HistoryBlock
149			Role:    "user",
150			Content: toolResults,
151		})
152
153		return r.Run(ctx, "")
154	}
155
156	return message.GetContent(), nil
157}

Själva koden är sammansatt av delar från denna fil.

Innehållet är ungefär följande:

  1. Skicka prompten och verktygslistan för att begära exekvering eller svarsgenerering.
  2. När ett svar genereras, stoppa rekursionen och returnera.
  3. Om LLM begär verktygsexekvering, anropar värden MCP Servern.
  4. Lägg till svaret i historiken och återgå till steg 1.

Avslutningsvis

Redan slut?

Faktum är att det inte finns så mycket att säga. Detta inlägg är skrivet för att hjälpa dig att förstå hur MCP Servern fungerar. Jag hoppas att detta inlägg har hjälpt dig att förstå MCP-värdens funktion, om än bara lite.