GoSuda

Memahami Host MCP secara Singkat

By snowmerak
views ...

Apa itu MCP

MCP adalah protokol yang dikembangkan oleh Anthropic untuk claude. MCP adalah singkatan dari Model Context Protocol, yaitu protokol yang memungkinkan LLM untuk secara aktif meminta tindakan atau sumber daya eksternal. Karena MCP benar-benar hanya protokol yang memberikan permintaan dan respons, proses dan eksekusinya harus dilakukan oleh pengembang.

Mengenai Cara Kerja Internal

Sebelum menjelaskan cara kerja internal, saya akan membahas Gemini Function Calling. Gemini Function Calling, sama seperti MCP, memungkinkan LLM untuk secara proaktif memanggil tindakan eksternal. Mungkin akan timbul pertanyaan mengapa Function Calling dibawa-bawa. Alasan mengapa Function Calling dibawa-bawa adalah karena Function Calling muncul lebih dulu daripada MCP, dan kompatibel karena sama-sama menggunakan skema OpenAPI, sehingga interaksi di antara keduanya diasumsikan serupa. Oleh karena itu, penjelasan Gemini Function Calling yang relatif lebih rinci dianggap dapat membantu, sehingga saya membawanya.

FunctionCalling

Alur keseluruhannya adalah sebagai berikut:

  1. Definisikan fungsi.
  2. Kirim definisi fungsi bersama dengan prompt ke Gemini.
    1. "Kirim prompt pengguna beserta deklarasi fungsi ke model. Model akan menganalisis permintaan dan menentukan apakah panggilan fungsi akan membantu. Jika demikian, model akan merespons dengan objek JSON terstruktur."
  3. Jika Gemini memerlukannya, ia akan meminta panggilan fungsi.
    1. Jika Gemini memerlukannya, pemanggil akan menerima nama dan parameter untuk panggilan fungsi.
    2. Pemanggil dapat memutuskan apakah akan mengeksekusi atau tidak.
      1. Apakah akan memanggil dan mengembalikan nilai yang valid
      2. Apakah akan mengembalikan data seolah-olah dipanggil tanpa benar-benar memanggilnya
      3. Apakah akan mengabaikannya saja
  4. Gemini melakukan dan meminta tindakan seperti memanggil beberapa fungsi sekaligus dalam proses di atas, atau memanggil lagi setelah melihat hasil panggilan fungsi.
  5. Akhirnya, proses berakhir ketika respons yang teratur telah dihasilkan.

Alur ini umumnya sejalan dengan MCP. Hal ini juga dijelaskan serupa dalam tutorial MCP. Ini juga mirip dengan ollama tools.

Dan syukurlah, ketiga alat ini, ollama tools, MCP, dan Gemini Function Calling, berbagi struktur skema sehingga dengan mengimplementasikan satu MCP saja, Anda dapat menggunakannya di ketiga tempat tersebut.

Oh, dan ada kelemahan yang dibagikan oleh semua. Karena pada akhirnya model yang mengeksekusinya, jika model yang Anda gunakan sedang dalam kondisi buruk, ia mungkin tidak memanggil fungsi, memanggilnya dengan aneh, atau melakukan kesalahan seperti meluncurkan DOS ke server MCP.

Host MCP dalam Go

mcphost milik mark3lab

Dalam Go, ada mcphost yang sedang dikembangkan oleh organisasi bernama mark3lab.

Cara penggunaannya sangat sederhana.

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

Setelah instalasi, buat file $HOME/.mcp.json dan tulis sebagai 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}

Dan jalankan dengan model ollama sebagai berikut. Tentu saja, jika perlu, unduh model dengan ollama pull mistral-small sebelumnya.

Meskipun secara default claude atau qwen2.5 direkomendasikan, untuk saat ini saya merekomendasikan mistral-small.

1mcphost -m ollama:mistral-small

Namun, jika dijalankan seperti ini, hanya dapat digunakan dalam mode tanya jawab di lingkungan CLI. Oleh karena itu, kami akan memodifikasi kode mcphost ini agar dapat beroperasi secara lebih terprogram.

mcphost Fork

Seperti yang sudah dikonfirmasi, mcphost menyertakan fungsionalitas untuk mengekstrak metadata dan memanggil fungsi menggunakan MCP. Oleh karena itu, diperlukan bagian untuk memanggil LLM, bagian untuk menangani server MCP, dan bagian untuk mengelola riwayat pesan.

Runner dari paket berikut adalah bagian yang diambil.

 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 yang relevan tidak akan kita lihat secara terpisah. Namun, namanya hampir sama persis.

 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 akan digunakan di sini, silakan lihat file ini. Untuk provider, kita akan menggunakan yang dari ollama, jadi silakan lihat file ini.

Hidangan 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 itu sendiri adalah potongan dari beberapa kode di file ini.

Isinya secara garis besar adalah sebagai berikut:

  1. Kirim prompt bersama dengan daftar alat untuk meminta eksekusi atau pembuatan respons.
  2. Jika respons telah dibuat, hentikan rekursi dan kembalikan.
  3. Jika LLM meninggalkan permintaan eksekusi alat, host akan memanggil MCP Server.
  4. Tambahkan respons ke riwayat dan kembali ke langkah 1.

Penutup

Sudah selesai?

Sebenarnya tidak banyak yang bisa dikatakan. Ini adalah artikel yang ditulis untuk membantu Anda memahami secara umum bagaimana MCP Server beroperasi. Saya harap artikel ini dapat sedikit membantu Anda dalam memahami cara kerja host MCP.