GoSuda

Memahami Sedikit tentang MCP Host

By snowmerak views ...

Apa itu MCP

MCP adalah protokol yang dikembangkan oleh Anthropic untuk Claude. MCP merupakan singkatan dari Model Context Protocol, yaitu protokol yang memungkinkan LLM secara aktif meminta tindakan atau sumber daya dari pihak eksternal. Karena MCP secara harfiah hanyalah protokol yang menyampaikan permintaan dan respons, proses serta eksekusinya harus diimplementasikan oleh pengembang.

Tentang mekanisme internal

Sebelum menjelaskan mekanisme internal, izinkan saya membahas terlebih dahulu Gemini Function Calling. Gemini Function Calling juga memungkinkan LLM secara proaktif memanggil tindakan eksternal, sama seperti MCP. Tentu akan timbul pertanyaan mengapa Function Calling perlu dibahas. Alasannya, Function Calling lebih dahulu dirilis dibandingkan MCP dan keduanya sama-sama menggunakan skema OpenAPI, sehingga kompatibel satu sama lain; oleh karena itu, saya menduga cara kerjanya serupa. Karena penjelasan Gemini Function Calling relatif lebih rinci, saya memasukkannya di sini karena diperkirakan akan membantu.

FunctionCalling

Alur keseluruhannya adalah sebagai berikut.

  1. Mendefinisikan fungsi.
  2. Mengirimkan definisi fungsi ke Gemini bersama dengan 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 meminta pemanggilan fungsi jika diperlukan.
    1. Jika Gemini memerlukannya, pemanggil (caller) menerima nama dan parameter untuk pemanggilan fungsi.
    2. Pemanggil dapat memutuskan apakah akan menjalankan atau tidak.
      1. Menjalankan pemanggilan dan mengembalikan nilai yang sah
      2. Tidak menjalankan pemanggilan, tetapi mengembalikan data seolah-olah pemanggilan telah dilakukan
      3. Mengabaikannya begitu saja
  4. Gemini dapat memanggil beberapa fungsi sekaligus dalam satu proses, atau memanggil fungsi lagi setelah meninjau hasil pemanggilan sebelumnya, dan meminta eksekusi atas tindakan tersebut.
  5. Proses berakhir ketika dihasilkan jawaban yang tersusun dengan baik.

Alur ini secara umum sejalan dengan MCP. Hal serupa juga dijelaskan dalam tutorial MCP. Alur ini juga mirip dengan ollama tools.

Dan yang sangat melegakan, ketiga perangkat ini, yaitu ollama tools, MCP, dan Gemini Function Calling, memiliki struktur skema yang nyaris sama, sehingga cukup dengan mengimplementasikan MCP, Anda dapat menggunakannya di ketiga platform tersebut.

Namun ada satu kelemahan yang dimiliki bersama. Karena eksekusi sepenuhnya dilakukan oleh model, apabila model yang Anda gunakan kurang baik, model dapat tidak memanggil fungsi, memanggilnya secara keliru, atau bahkan melakukan tindakan yang tidak semestinya seperti membanjiri server MCP dengan permintaan (DoS).

Host MCP berbasis Go

mcphost milik mark3lab

Di Go terdapat mcphost yang sedang dikembangkan oleh organisasi bernama mark3lab.

Cara penggunaannya sangat sederhana.

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

Setelah instalasi, buat berkas $HOME/.mcp.json dan tulis seperti berikut.

 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}

Lalu jalankan dengan model ollama seperti berikut.
Tentunya, jika diperlukan, unduh model terlebih dahulu dengan ollama pull mistral-small.

Secara umum Claude atau qwen2.5 direkomendasikan, tetapi untuk saat ini saya merekomendasikan mistral-small.

1mcphost -m ollama:mistral-small

Namun, dengan cara ini, penggunaannya terbatas pada tanya jawab di lingkungan CLI.
Oleh karena itu, kita akan memodifikasi kode mcphost ini agar dapat beroperasi secara lebih programmable.

Fork mcphost

Seperti yang telah kita lihat, mcphost sudah memiliki fitur untuk mengekstraksi metadata dan memanggil fungsi melalui MCP. Oleh karena itu, diperlukan bagian yang memanggil LLM, bagian yang menangani server MCP, dan bagian yang mengelola riwayat pesan.

Bagian-bagian tersebut dikumpulkan dalam Runner pada paket berikut.

 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}

Deklarasi internal dari bagian tersebut tidak akan dibahas secara terpisah. Namun, namanya hampir sepenuhnya mencerminkan fungsinya.

 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}

Untuk mcpClients dan tools yang digunakan di sini, silakan periksa berkas terkait.
Untuk provider, kita akan menggunakan milik ollama, jadi silakan periksa berkas terkait.

Bagian utamanya adalah metode 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}

Kode ini merupakan gabungan dari sebagian kode pada berkas terkait.

Secara garis besar, alurnya adalah sebagai berikut.

  1. Mengirimkan daftar tool bersama prompt untuk meminta apakah perlu dieksekusi atau untuk menghasilkan respons.
  2. Jika respons telah dihasilkan, rekursi dihentikan dan respons dikembalikan.
  3. Jika LLM meminta eksekusi tool, host memanggil server MCP.
  4. Hasilnya ditambahkan ke riwayat, lalu kembali ke langkah 1.

Penutup

Sudah selesai?

Sebenarnya, tidak banyak yang perlu disampaikan. Tulisan ini dibuat untuk membantu pemahaman tentang cara kerja server MCP secara garis besar. Semoga tulisan ini sedikit membantu Anda dalam memahami cara kerja host MCP.