Az MCP host működésének rövid megismerése

Mi az MCP

Az MCP az Anthropic által a Claude számára kifejlesztett protokoll. Az MCP a Model Context Protocol rövidítése, amely lehetővé teszi, hogy a LLM aktívan kérjen műveleteket vagy erőforrásokat külső rendszerektől. Mivel az MCP szó szerint csupán kéréseket és válaszokat továbbító protokoll, a folyamatot és a végrehajtást a fejlesztőnek kell megvalósítania.

A belső működésről

Mielőtt a belső működést ismertetnénk, röviden érintjük a Gemini Function Calling témakörét. A Gemini Function Calling is az MCP-hez hasonlóan lehetővé teszi, hogy a LLM kezdeményezően hívjon meg külső műveleteket. Felmerülhet a kérdés, miért hoztuk szóba éppen a Function Callingot. Azért, mert a Function Calling korábban jelent meg, mint az MCP, és mivel mindkettő OpenAPI sémát használ, kompatibilisek egymással, így működésük hasonló lehet. Mivel a Gemini Function Calling leírása részletesebb, feltételezhetően segítséget nyújt, ezért hoztuk szóba.

Az általános folyamat a következő:

1. Függvényt definiálunk.
2. A promptdal együtt elküldjük a függvénydefiníciót a Gemininek.
   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. A Gemini szükség esetén függvényhívást kér.
   1. Ha a Gemini szükségesnek ítéli, a hívó megkapja a függvényhíváshoz szükséges nevet és paramétereket.
   2. A hívó dönthet arról, hogy végrehajtja-e a hívást, vagy sem.
      1. Meghívja a függvényt, és érvényes értéket ad vissza.
      2. Nem hívja meg, hanem úgy ad vissza adatot, mintha meghívta volna.
      3. Egyszerűen figyelmen kívül hagyja.
4. A Gemini a fenti folyamat során egyszerre több függvényt is hívhat, vagy a függvényhívás eredményét megvizsgálva újabb hívást kezdeményezhet.
5. Végül, amikor rendezett válasz születik, a folyamat véget ér.

Ez a folyamat általánosságban összhangban van az MCP-vel. Ezt hasonlóan írja le az MCP oktatóanyaga is. Az ollama tools is hasonló módon működik.

Szerencsére a három eszköz, az ollama tools, az MCP és a Gemini Function Calling sémaszerkezete gyakorlatilag közös, ezért elegendő egyetlen MCP-t megvalósítani ahhoz, hogy mindhárom helyen használni lehessen.

Van azonban egy közös hátrány is. Mivel a végrehajtást végül a modell kezdeményezi, ha a használt modell gyenge állapotban van, előfordulhat, hogy nem hív meg függvényt, rosszul hívja meg, vagy DoS-szerű terhelést okoz az MCP szerveren.

MCP host Go nyelven

mark3lab mcphost

Go nyelvhez létezik a mark3lab szervezet által fejlesztett mcphost.

A használata rendkívül egyszerű.

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

A telepítés után hozzuk létre a $HOME/.mcp.json fájlt, és az alábbi módon írjuk meg:

 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}

Ezután futtassuk az alábbi módon, ollama modellel.
Természetesen szükség esetén előtte letöltjük a modellt a ollama pull mistral-small paranccsal.

Alapvetően a claude vagy a qwen2.5 modellt ajánlom, de jelenleg én a mistral-smallt javasolom.

1mcphost -m ollama:mistral-small

Ilyen módon azonban csak CLI környezetben, kérdés-válasz formában használhatjuk. Ezért most módosítjuk a mcphost kódját, hogy programozhatóbban tudjon működni.

Az mcphost fork

Ahogy már láttuk, az mcphost tartalmaz olyan funkciót, amely MCP segítségével metaadatokat nyer ki és függvényeket hív meg. Ezért szükség van a LLM hívásáért felelős részre, az MCP szerverek kezelésére és az üzenettörténet kezelésére.

Az ehhez szükséges részeket egy csomag Runner típusába emeltük ki:

 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}

A típus belső deklarációit nem vizsgáljuk külön, mert nagyjából a nevük alapján érthetők.

 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}

A itt használt mcpClients és tools részleteiért nézze meg a megfelelő fájlt.
A provider esetében az ollama implementációt fogjuk használni, ezért nézze meg a megfelelő fájlt.

A főszereplő a Run metódus.

  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}

A kód maga a megfelelő fájl egyes részeinek összeillesztésével készült.

A tartalma nagyjából a következő:

1. A prompttal együtt elküldjük az eszközök listáját, és kérjük a végrehajtás eldöntését vagy válaszgenerálást.
2. Amikor létrejön a válasz, megszakítjuk a rekurziót, és visszaadjuk.
3. Ha a LLM eszközvégrehajtási kérést hagy hátra, a host meghívja az MCP Servert.
4. A választ hozzáadjuk a történethez, és visszatérünk az 1. pontra.

Befejezés

Máris vége?

Valójában nincs túl sok mondanivalónk. Ez az írás főként azért készült, hogy segítsen megérteni, hogyan működik az MCP Server. Remélem, hogy ez kis mértékben hozzájárult ahhoz, hogy megértsd az MCP host működését.