Protobufλ‘ MCP μλ² κ΅¬μΆνκΈ° 2λΆ: protoc νλ¬κ·ΈμΈμΌλ‘ MCP μλ² μλ μμ±
μμ±μ: EDB Korea Team
2025λ 9μ 21μΌ
μ΄ λΈλ‘κ·Έ μ리μ¦μμλ μ μ©ν λꡬλ€λ‘ κ°λ μ°¬ MCP (Model Context Protocol) μλ²λ₯Ό ꡬμΆνλ λ°©λ²μ 보μ¬λ립λλ€. μ²μλΆν° μμνλ λμ , κΈ°μ‘΄μ νλ‘ν μ½ λ²νΌμ Googleμ gRPC νΈλμ€μ½λ©μ νμ©ν κ²μ λλ€. λ§μΆ€ν protoc (νλ‘ν μ½ λ²νΌ μ»΄νμΌλ¬) νλ¬κ·ΈμΈμ μμ±νμ¬ MCP μλ²λ₯Ό μλμΌλ‘ μμ±ν μ μμ΅λλ€. μ΄ ν΅ν©λ μ κ·Ό λ°©μμ ν΅ν΄ gRPC μλΉμ€, OpenAPI μ¬μ, REST API λ° MCP μλ²λ₯Ό λͺ¨λ λμΌν μμ€μμ μμ±ν μ μμ΅λλ€.
μ΄ λΈλ‘κ·Έ μ리μ¦λ 4νΈμΌλ‘ ꡬμ±λμ΄ μμ΅λλ€
- 1λΆ: gRPC νΈλμ€μ½λ©μ μ¬μ©νμ¬ Protobufμμ REST API μμ±νκΈ°
- 2λΆ: (λ³Έ κΈ°μ¬) Protoc νλ¬κ·ΈμΈμΌλ‘ MCP μλ² μμ± μλννκΈ°
- 3λΆ: Proto μ£ΌμμΌλ‘ AI μνΈμμ© ν₯μμν€κΈ°
- 4λΆ: μ€μ λ‘ MCP λꡬλ₯Ό μ€ννλ©΄μ μ»μ ν΅μ°°λ ₯
Protobuf κΈ°λ° MCP μλ² μλν κ΅¬μ± μμ
μ΄ νν 리μΌμ λ§μΉλ©΄ λ€μμ κ°κ² λ©λλ€:
- proto νμΌμμ MCP μλ²λ₯Ό μμ±νλ λ§μΆ€ν protoc νλ¬κ·ΈμΈ
- μ΄λ€ λ©μλκ° MCP λκ΅¬κ° λ μ§ νμνλ λ§μΆ€ν μ΄λ Έν μ΄μ
- νλμ μμ€μμ gRPC, REST, MCP μ½λλ₯Ό μμ±νλ μμ ν νμ΄νλΌμΈ
- AI μμ΄μ νΈκ° μνΈμμ©ν μ μλ μλνλ MCP μλ²
μ΄ κΈ°μ¬μ μΈκΈλ λͺ¨λ μ½λλ GitHub μ μ₯μ zhangcz828/proto-to-mcp-tutorialμμ μ°Ύμ μ μμ΅λλ€.
μ μ 쑰건
μμνκΈ° μ μ, 1λΆλ₯Ό μλ£νμΌλ©° λ€μμ κ°μΆκ³ μλμ§ νμΈνμΈμ:
- 1λΆμ μμ νν λ¦¬μΌ νλ‘μ νΈ
- Go 1.19+ μ€μΉ
- Protocol Buffer μ»΄νμΌλ¬ (protoc) μ€μΉ
- Python 3.8+ μ€μΉ (MCP μλ² λ°νμμ©)
- npx μ€μΉ
Protobuf νλ¬κ·ΈμΈμΌλ‘ MCP μλ²λ₯Ό μλ μμ±νλ μ΄μ
1λΆμμλ gRPC νΈλμ€μ½λ©μ΄ gRPC λ° REST API μ μλ₯Ό ν΅ν©νλ λ° μ΄λ»κ² λμμ΄ λλμ§ λ³΄μ¬λλ Έμ΅λλ€. proto νμΌμμ μλμΌλ‘ μμ±λ κΉ¨λνκ³ λ¬Έμνκ° μ λ HTTP μλν¬μΈνΈλ₯Ό κ°κ² λμμ£ . νμ§λ§ κ³§ μλ‘μ΄ λ¬Έμ μ μ§λ©΄νμ΅λλ€. Model Context Protocolμ ν΅ν΄ AI μμ€ν μ΄ μλΉμ€μ μνΈμμ©νλλ‘ λ§λ€κ³ μΆμλ κ²μ λλ€.
MCPλ AI μ ν리μΌμ΄μ μ΄ λꡬμ 리μμ€μ νλ‘κ·Έλλ° λ°©μμΌλ‘ μ κ·ΌνκΈ° μν νμ€νλ λ°©λ²μ λλ€. μ°λ¦¬μ ν΅ν©λ μ κ·Ό λ°©μμ΄ μμλ€λ©΄, κ° μλΉμ€μ λν΄ μλμΌλ‘ MCP μλ² μ½λλ₯Ό μμ±ν΄μΌ νμ κ²μ λλ€. μ΄λ κΈ°λ³Έμ μΌλ‘ gRPC μλΉμ€, REST μλν¬μΈνΈ λ° OpenAPI μ¬μκ³Ό ν¨κ» μ μ§ κ΄λ¦¬ν΄μΌ ν λ€ λ²μ§Έ API μ μ μΈνΈλ₯Ό λ§λλ κ²κ³Ό κ°μμ΅λλ€.
μ΄λ μ°λ¦¬λ protoc κΈ°λ° μ κ·Ό λ°©μμ νμ₯ν μ μλ€λ κ²μ κΉ¨λ¬μμ΅λλ€. proto νμΌμμ REST APIμ OpenAPI μ¬μμ μμ±ν μ μλ€λ©΄, MCP μλ²λ μμ±ν μ μμ§ μμκΉμ? REST μλν¬μΈνΈ μμ±μ μλ΄νλ λμΌν HTTP μ΄λ Έν μ΄μ μ΄ MCP λꡬλ₯Ό ꡬ쑰ννλ λ°©λ²μ μλ €μ€ μ μμμ΅λλ€.
Protobuf MCP μλ² νλ‘μ νΈ μ€μ
1λΆμ νν λ¦¬μΌ νλ‘μ νΈλ₯Ό νμ₯νλ κ²λΆν° μμνκ² μ΅λλ€. νν λ¦¬μΌ λλ ν λ¦¬λ‘ λμκ° λ€μ λͺ λ Ήμ μ€ννμΈμ:
cd proto-to-mcp-tutorial
# νλ¬κ·ΈμΈ λ° MCP μ½λμ© λλ ν 리 μμ±
mkdir -p plugins/protoc-gen-mcp
mkdir -p generated/mcp
mkdir -p google/protobuf
mkdir -p mcp/protobuf
νλ‘μ νΈ κ΅¬μ‘°λ μ΄μ MCP κ΄λ ¨ λλ ν λ¦¬κ° μΆκ°λμ΄ λ€μκ³Ό κ°μμΌ ν©λλ€:
proto-to-mcp-tutorial
βββ cmd
β βββ server
β βββ main.go
βββ generate.sh
βββ generated
β βββ go
β β βββ bookstore_grpc.pb.go
β β βββ bookstore.pb.go
β β βββ bookstore.pb.gw.go
β βββ mcp # New
β βββ openapi
β βββ openapi.yaml
βββ go.mod
βββ go.sum
βββ google
β βββ protobuf # New
βββ mcp # New
β βββ protobuf
βββ googleapis
β βββ google
β βββ api
β βββ annotations.proto
β βββ http.proto
βββ plugins # New
β βββ protoc-gen-mcp
βββ proto
β βββ bookstore.proto
βββ README.md
MCP λꡬ μ§μ μ μν λ§μΆ€ν μ΄λ Έν μ΄μ μμ±
1. νμ proto νμΌ λ€μ΄λ‘λ
curl -o google/protobuf/descriptor.proto \
https://raw.githubusercontent.com/protocolbuffers/protobuf/refs/heads/main/src/google/protobuf/descriptor.proto
2. MCP μ΄λ Έν μ΄μ μ μ
μ΄λ€ RPC λ©μλκ° MCP λκ΅¬κ° λμ΄μΌ νλμ§ νμνκΈ° μν΄ λ§μΆ€ν μ΄λ
Έν
μ΄μ
μ μμ±ν΄μΌ ν©λλ€. μ νμΌ mcp/protobuf/annotations.protoλ₯Ό μμ±ν©λλ€:
syntax = "proto3";
package example.v1;
option go_package = "proto-to-mcp-tutorial/generated/go/mcp;mcp";
import "google/protobuf/descriptor.proto";
// λ©μλλ₯Ό MCP λκ΅¬λ‘ νμνκΈ° μν λ§μΆ€ νμ₯ (50003μ μ¬μ©μ μ§μ νμ₯ νλ λ²νΈ)
extend google.protobuf.MethodOptions {
MCPOptions mcp = 50003;
}
message MCPOptions {
// μ΄ λ©μλκ° MCP λκ΅¬λ‘ λ
ΈμΆλμ΄μΌ νλμ§ μ¬λΆ
bool enabled = 1;
}
3. MCP μ΄λ Έν μ΄μ μ© Go μ½λ μμ±
export GOOGLEAPIS_DIR=./googleapis
export MCP_DIR=.
protoc -I${GOOGLEAPIS_DIR} -I${MCP_DIR} --go_out=./generated/go --go_opt=paths=source_relative mcp/protobuf/annotations.proto
MCP μ΄λ Έν μ΄μ μΌλ‘ Bookstore Proto νμΌ μ λ°μ΄νΈ
μ΄μ proto/bookstore.proto νμΌμ MCP μ΄λ
Έν
μ΄μ
μ μΆκ°νμ¬ μ΄λ€ λ©μλλ₯Ό MCP λκ΅¬λ‘ νμ±νν μ§ νμν©λλ€.
syntax = "proto3";
package bookstore.v1;
import "google/api/annotations.proto";
import "mcp/protobuf/annotations.proto";
option go_package = "generated/go/bookstore/v1";
service BookstoreService {
// Get a book by ID
rpc GetBook(GetBookRequest) returns (Book) {
option (google.api.http) = {
get: "/v1/books/{book_id}"
};
option (mcp.v1.tool) = {
enabled: true
};
}
// Create a new book
rpc CreateBook(CreateBookRequest) returns (Book) {
option (google.api.http) = {
post: "/v1/books"
body: "book"
};
option (mcp.v1.tool) = {
enabled: true
};
}
}
message Book {
string book_id = 1;
string title = 2;
string author = 3;
int32 pages = 4;
}
message GetBookRequest {
// The ID of the book to retrieve
string book_id = 1;
}
message CreateBookRequest {
// The book object to create
Book book = 1;
}
protoc-gen-mcp νλ¬κ·ΈμΈ ꡬμΆ
plugins/protoc-gen-mcp/main.go νμΌμ λ§μΆ€ν protoc νλ¬κ·ΈμΈ μ½λλ₯Ό μμ±ν©λλ€. μ΄ Go νλ¬κ·ΈμΈμ proto νμΌμ ꡬ문 λΆμνκ³ , MCP μ΄λ
Έν
μ΄μ
μ νμΈν λ€μ, Python MCP μλ² μ½λλ₯Ό μμ±ν©λλ€.
package main
import (
"bytes"
"fmt"
"regexp"
"strings"
"text/template"
"google.golang.org/protobuf/compiler/protogen"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/types/descriptorpb"
"google.golang.org/protobuf/types/pluginpb"
mcpannotations "proto-to-mcp-tutorial/generated/go/mcp/protobuf"
httpannotations "google.golang.org/genproto/googleapis/api/annotations"
)
func main() {
protogen.Options{}.Run(func(gen *protogen.Plugin) error {
gen.SupportedFeatures = uint64(pluginpb.CodeGeneratorResponse_FEATURE_PROTO3_OPTIONAL)
// Extract MCP methods from the proto files
mcpMethods := extractMCPMethods(gen)
if len(mcpMethods) == 0 {
return nil // No MCP methods found
}
// Generate main server file
generateMCPServer(gen, mcpMethods)
return nil
})
}
type MCPMethod struct {
Service *protogen.Service
Method *protogen.Method
ToolName string
Description string
HTTPInfo *HTTPInfo
Input *protogen.Message
Output *protogen.Message
Parameters []*MCPParameter
}
type MCPParameter struct {
Name string
Type string
Required bool
Description string
}
type HTTPInfo struct {
Method string
Path string
Body string
}
func extractMCPMethods(gen *protogen.Plugin) []*MCPMethod {
var mcpMethods []*MCPMethod
for _, file := range gen.Files {
if !file.Generate {
continue
}
for _, service := range file.Services {
for _, method := range service.Methods {
if hasMCPToolAnnotation(method) {
mcpMethod := &MCPMethod{
Service: service,
Method: method,
ToolName: generateToolName(method),
Description: extractDescription(method),
HTTPInfo: extractHTTPInfo(method),
Input: method.Input,
Output: method.Output,
Parameters: extractParameters(method.Input),
}
mcpMethods = append(mcpMethods, mcpMethod)
}
}
}
}
return mcpMethods
}
func hasMCPToolAnnotation(method *protogen.Method) bool {
options := method.Desc.Options().(*descriptorpb.MethodOptions)
if options == nil {
return false
}
// Check if method has mcp.v1.tool annotation
if !proto.HasExtension(options, mcpannotations.E_Tool) {
return false
}
// Get annotation value and check if enabled
toolOptions := proto.GetExtension(options, mcpannotations.E_Tool).(*mcpannotations.MCPToolOptions)
return toolOptions != nil && toolOptions.Enabled
}
func extractParameters(inputType *protogen.Message) []*MCPParameter {
var parameters []*MCPParameter
if inputType != nil {
for _, field := range inputType.Fields {
param := &MCPParameter{
Name: string(field.Desc.Name()),
Type: getFieldType(field),
Required: isFieldRequired(field),
Description: extractFieldDescription(field),
}
parameters = append(parameters, param)
}
}
return parameters
}
func isFieldRequired(field *protogen.Field) bool {
// In proto3, technically all fields are optional, but for business logic:
// If the field not marked as optional keyword, consider it required
if field.Desc.HasOptionalKeyword() {
return false
}
return true
}
func getFieldType(field *protogen.Field) string {
// Check if the field is repeated (array/list)
if field.Desc.Cardinality() == protoreflect.Repeated {
return "list"
}
switch field.Desc.Kind() {
case protoreflect.StringKind:
return "string"
case protoreflect.Int32Kind, protoreflect.Int64Kind:
return "integer"
case protoreflect.BoolKind:
return "boolean"
case protoreflect.MessageKind:
return "object"
case protoreflect.EnumKind:
return "string"
default:
return "string"
}
}
func extractFieldDescription(field *protogen.Field) string {
if field.Comments.Leading != "" {
return strings.TrimSpace(string(field.Comments.Leading))
}
return ""
}
func generateToolName(method *protogen.Method) string {
methodName := string(method.Desc.Name())
// Convert to snake_case
methodName = camelToSnake(methodName)
return methodName
}
func camelToSnake(str string) string {
re := regexp.MustCompile("([a-z0-9])([A-Z])")
snake := re.ReplaceAllString(str, "${1}_${2}")
return strings.ToLower(snake)
}
func extractDescription(method *protogen.Method) string {
if method.Comments.Leading != "" {
return strings.TrimSpace(string(method.Comments.Leading))
}
return fmt.Sprintf("Execute %s RPC method", method.Desc.Name())
}
func extractHTTPInfo(method *protogen.Method) *HTTPInfo {
options := method.Desc.Options().(*descriptorpb.MethodOptions)
if options == nil {
return nil
}
if !proto.HasExtension(options, httpannotations.E_Http) {
return nil
}
httpRule := proto.GetExtension(options, httpannotations.E_Http).(*httpannotations.HttpRule)
if httpRule == nil {
return nil
}
info := &HTTPInfo{}
switch pattern := httpRule.Pattern.(type) {
case *httpannotations.HttpRule_Get:
info.Method = "GET"
info.Path = pattern.Get
case *httpannotations.HttpRule_Post:
info.Method = "POST"
info.Path = pattern.Post
info.Body = httpRule.Body
case *httpannotations.HttpRule_Put:
info.Method = "PUT"
info.Path = pattern.Put
info.Body = httpRule.Body
case *httpannotations.HttpRule_Delete:
info.Method = "DELETE"
info.Path = pattern.Delete
case *httpannotations.HttpRule_Patch:
info.Method = "PATCH"
info.Path = pattern.Patch
info.Body = httpRule.Body
}
return info
}
func generateMCPServer(gen *protogen.Plugin, mcpMethods []*MCPMethod) {
outputFile := gen.NewGeneratedFile("mcp_server.py", ".")
funcMap := template.FuncMap{
"contains": func(s, substr string) bool {
return strings.Contains(s, substr)
},
"printf": fmt.Sprintf,
"indent": func(text string, spaces int) string {
if text == "" {
return text
}
lines := strings.Split(text, "\n")
indentStr := strings.Repeat(" ", spaces)
var result []string
for i, line := range lines {
if strings.TrimSpace(line) != "" {
result = append(result, indentStr+line)
} else if i < len(lines)-1 { // Keep empty lines except the last one
result = append(result, "")
}
}
return strings.Join(result, "\n")
},
}
tmpl := template.Must(template.New("mcp_server").Funcs(funcMap).Parse(mcpServerTemplate))
var buf bytes.Buffer
if err := tmpl.Execute(&buf, mcpMethods); err != nil {
return
}
outputFile.P(buf.String())
}
const mcpServerTemplate = `#!/usr/bin/env python3
"""
MCP Server for UPM API - Auto-generated from Protocol Buffers
This server provides access to project management operations
through the Model Context Protocol.
"""
import os
import sys
from typing import Any
import json
import httpx
from mcp.server.fastmcp import FastMCP
API_BASE = 'http://localhost:8080'
VERIFY_SSL = False
# Initialize FastMCP
mcp = FastMCP('Bookstore Server')
async def make_api_request(url: str, method: str = "GET", payload: dict = None) -> dict[str, Any] | None:
"""Make a HTTP request to the specified URL."""
headers = {
"Content-Type": "application/json",
}
# Use SSL verification based on environment variable
async with httpx.AsyncClient(verify=VERIFY_SSL) as client:
try:
if method.upper() == "GET":
response = await client.get(url, headers=headers, timeout=30.0)
elif method.upper() == "PUT":
response = await client.put(url, headers=headers, json=payload, timeout=30.0)
elif method.upper() == "POST":
response = await client.post(url, headers=headers, json=payload, timeout=30.0)
elif method.upper() == "DELETE":
response = await client.delete(url, headers=headers, timeout=30.0)
elif method.upper() == "PATCH":
response = await client.patch(url, headers=headers, json=payload, timeout=30.0)
else:
return {"error": f"Unsupported HTTP method: {method}"}
response.raise_for_status()
# Handle DELETE responses that might be empty
if method.upper() == "DELETE":
if response.status_code == 200 or response.status_code == 204:
return {"success": True, "message": "Resource deleted successfully"}
# Try to parse JSON, return empty dict if no content
try:
return response.json()
except:
return {"success": True}
except httpx.HTTPStatusError as e:
return {"error": f"HTTP {e.response.status_code}: {e.response.text}"}
except Exception as e:
return {"error": str(e)}
# MCP Tools
{{range .}}
@mcp.tool()
async def {{.ToolName}}({{range $i, $param := .Parameters}}{{if $i}}, {{end}}{{$param.Name}}: {{if eq $param.Type "string"}}str{{else if eq $param.Type "integer"}}int{{else if eq $param.Type "boolean"}}bool{{else if eq $param.Type "list"}}list{{else}}dict{{end}}{{if not $param.Required}} = None{{end}}{{end}}) -> str:
"""{{.Description}}
{{if .HTTPInfo}}
HTTP: {{.HTTPInfo.Method}} {{.HTTPInfo.Path}}{{end}}
Parameters:{{range .Parameters}}
- {{.Name}} ({{.Type}}{{if not .Required}}, optional{{end}}): {{if contains .Description "\n"}}{{indent .Description 6}}{{else}}{{.Description}}{{end}}{{end}}
Returns:
- str: JSON formatted response from the API containing the result or error information
"""
try:
{{if .HTTPInfo}}
# Construct the URL
url = f"{API_BASE}{{.HTTPInfo.Path}}"
{{$httpInfo := .HTTPInfo}}{{range .Parameters}}{{if and .Required (contains $httpInfo.Path (printf "{%s}" .Name))}}
url = url.replace("{" + "{{.Name}}" + "}", str({{.Name}})){{end}}{{end}}
# Prepare payload for non-GET requests
payload = {}
{{range .Parameters}}{{if and (ne $httpInfo.Method "GET") (ne $httpInfo.Method "DELETE") (not (contains $httpInfo.Path (printf "{%s}" .Name)))}}
{{if .Required}}payload["{{.Name}}"] = {{.Name}}{{else}}if {{.Name}} is not None:
payload["{{.Name}}"] = {{.Name}}{{end}}{{end}}{{end}}
# Make the API request
result = await make_api_request(url, "{{.HTTPInfo.Method}}", payload if payload else None)
{{else}}
result = {"error": "No HTTP endpoint defined for this method"}{{end}}
# Return formatted JSON response
import json
return json.dumps(result, indent=2)
except Exception as e:
# Handle any errors that occur during execution
import json
error_result = {
"error": f"Tool execution failed: {str(e)}",
"tool_name": "{{.ToolName}}",
"error_type": type(e).__name__
}
return json.dumps(error_result, indent=2)
{{end}}
if __name__ == '__main__':
# Run the MCP server
mcp.run()
`νλ¬κ·ΈμΈ μ»΄νμΌ
# νλ‘μ νΈ λ£¨νΈ κ²½λ‘μμ μ€ν
go build -o protoc-gen-mcp plugins/protoc-gen-mcp/main.go
gRPCΒ·RESTΒ·OpenAPIΒ·MCP μ½λ ν΅ν© μμ±
generate.sh μ€ν¬λ¦½νΈλ₯Ό μ
λ°μ΄νΈνμ¬ MCP μλ² μμ± λ¨κ³λ₯Ό ν¬ν¨ν©λλ€.
#!/bin/bash
export GOOGLEAPIS_DIR=./googleapis
export MCP_DIR=.
echo "Checking for required protoc plugins..."
# Check if protoc-gen-go is available
if ! command -v protoc-gen-go &> /dev/null; then
echo "β protoc-gen-go not found. Installing..."
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
if [ $? -ne 0 ]; then
echo "β οΈ Failed to install protoc-gen-go. Skipping Go generation."
exit 1
fi
fi
# Check if protoc-gen-go-grpc is available
if ! command -v protoc-gen-go-grpc &> /dev/null; then
echo "β protoc-gen-go-grpc not found. Installing..."
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
if [ $? -ne 0 ]; then
echo "β οΈ Failed to install protoc-gen-go-grpc. Skipping gRPC generation."
exit 1
fi
fi
# Check if protoc-gen-grpc-gateway is available
if ! command -v protoc-gen-grpc-gateway &> /dev/null; then
echo "β protoc-gen-grpc-gateway not found. Installing..."
go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway@latest
if [ $? -ne 0 ]; then
echo "β οΈ Failed to install protoc-gen-grpc-gateway. Skipping Gateway generation."
exit 1
fi
fi
echo "π§ Generating Go gRPC code..."
# Step 1: Generate Go code for MCP annotations
echo "π§ Generating MCP annotations Go code..."
protoc -I${GOOGLEAPIS_DIR} -I${MCP_DIR} --go_out=./generated/go --go_opt=paths=source_relative mcp/protobuf/annotations.proto
# Step 2: Generate Go gRPC code
protoc -I${GOOGLEAPIS_DIR} -I${MCP_DIR} --proto_path=proto --go_out=./generated/go --go_opt paths=source_relative --go-grpc_out=./generated/go --go-grpc_opt paths=source_relative bookstore.proto
# Generate gRPC Gateway for REST endpoints
echo "π§ Generating gRPC Gateway..."
protoc -I${GOOGLEAPIS_DIR} -I${MCP_DIR} --proto_path=proto --grpc-gateway_out=./generated/go --grpc-gateway_opt paths=source_relative bookstore.proto
# Generate OpenAPI specifications
echo "π§ Generating OpenAPI spec..."
protoc -I${GOOGLEAPIS_DIR} -I${MCP_DIR} -I./proto --openapi_out=./generated/openapi \
--openapi_opt=fq_schema_naming=true \
--openapi_opt=version="1.0.0" \
--openapi_opt=title="Bookstore API" \
bookstore.proto
# Generate MCP server (always available since we have our custom plugin)
echo "π§ Generating MCP server..."
protoc -I${GOOGLEAPIS_DIR} -I${MCP_DIR} --proto_path=proto \
--plugin=protoc-gen-mcp=./protoc-gen-mcp \
--mcp_out=./generated/mcp \
bookstore.proto
echo ""
echo "π Generation complete!"
echo "π Check the ./generated directory for all generated files."μ λ°μ΄νΈλ μμ± μ€ν¬λ¦½νΈλ₯Ό μ€νν©λλ€:
./generate.sh
μλμ κ°μ κ²°κ³Όκ°μ λ³Ό μ μμ΅λλ€:
Checking for required protoc plugins...π§ Generating Go gRPC code...π§ Generating MCP annotations Go code...π§ Generating gRPC Gateway...π§ Generating OpenAPI spec...π§ Generating MCP server...π Generation complete!π Check the ./generated directory for all generated files.
μμ±λ MCP μλ² μ€ν λ° ν μ€νΈ
1. Go μλ² μμ (ν°λ―Έλ 1)
ν°λ―Έλ 1μμ λ€μ λͺ λ Ήμ μ€ννμ¬ (1λΆμμ ꡬμΆν) Go μλ²λ₯Ό μμν©λλ€. μ΄ μλ²λ gRPC μλΉμ€μ REST κ²μ΄νΈμ¨μ΄ μν μ λͺ¨λ μνν©λλ€.
2. MCP μλ² μ€μ λ° μμ (ν°λ―Έλ 2)
uv (Python ν¨ν€μ§ κ΄λ¦¬μ)λ₯Ό μ€μΉν ν, νκ²½μ μ€μ νκ³ MCP μλ²λ₯Ό μμν©λλ€:
# Create Python virtual environmentuv venvsource .venv/bin/activate# Install MCP server dependenciesuv pip install fastmcp httpx --native-tls# Start MCP Inspectornpx @modelcontextprotocol/inspector \uv \--directory ./generated/mcp \run \mcp_server.py
3. MCP λꡬ λͺ©λ‘ ν μ€νΈ
μ΄λ¦° MCP Inspector UI νμ΄μ§μμ μ°κ²°ν λ€μ λͺ¨λ λꡬλ₯Ό λμ΄νλ©΄, get_bookκ³Ό create_book λ κ°μ§ λκ΅¬κ° νμλμ΄μΌ ν©λλ€.

4. λꡬ μ€ν ν μ€νΈ
get_book λꡬλ₯Ό μ ννκ³ , book_idμ book-1μ μ
λ ₯νκ³ μ€νν©λλ€. μ΄λ curl -X GET http://localhost:8080/v1/books/book-1κ³Ό λμΌν κ²°κ³Όλ₯Ό λ°νν΄μΌ ν©λλ€.

Protobuf κΈ°λ° MCP μλ² μλ μμ± κ²°κ³Ό
μ΄μ νλμ proto νμΌμ΄ μΈ κ°μ§ λ€λ₯Έ μΈν°νμ΄μ€λ₯Ό μμ±νλ μμ ν νμ΄νλΌμΈμ κ°κ² λμμ΅λλ€:
# Test gRPC interfacegrpcurl -plaintext -d '{"book_id": "book-1"}' localhost:9090 bookstore.v1.BookstoreService/GetBook# Test REST interface curl http://localhost:8080/v1/books/book-1# Test MCP interface (as shown above)
μΈ κ°μ§ λͺ¨λ λμΌν λΆ λ°μ΄ν°λ₯Ό λ°νν΄μΌ ν©λλ€!
λμΌν proto νμΌμ μ΄μ gRPC μλΉμ€, REST μλν¬μΈνΈ, OpenAPI μ¬μ λ° MCP λꡬλ₯Ό μμ±νλ λ° νμν λͺ¨λ κ²μ΄ ν¬ν¨λμ΄ μμ΅λλ€.

λ€μ λ¨κ³: Proto μ£ΌμμΌλ‘ AI μνΈμμ© κ°μ
μμ±λ MCP λꡬλ₯Ό AI μμ΄μ νΈλ‘ ν μ€νΈνκΈ° μμνμ λ, μλνλ λꡬλ§μΌλ‘λ μΆ©λΆνμ§ μλ€λ μ€μν μ¬μ€μ λΉ λ₯΄κ² κΉ¨λ¬μμ΅λλ€. AI μμ΄μ νΈλ κ° λκ΅¬κ° λ¬΄μμ νλμ§, μΈμ μ μ νκ² μ¬μ©ν΄μΌ νλμ§ μ΄ν΄νκΈ° μν΄ νλΆνκ³ μμΈν μ€λͺ μ΄ νμν©λλ€. 3λΆμμλ proto μ£Όμμ΄ AI μνΈμμ©μ μλ΄νλ μ§λ₯μ μΈ MCP λꡬ λ¬Έμκ° λλ λ°©λ²μ 보μ¬μ€ κ²μ λλ€.
Protobuf κΈ°λ° MCP μλ² μλ μμ± FAQ
protoc νλ¬κ·ΈμΈμΌλ‘ MCP μλ²λ₯Ό μλ μμ±νλ μ΄μ λ 무μμΈκ°μ?
gRPC μλΉμ€, REST μλν¬μΈνΈ, OpenAPI μ¬μκ³Ό MCP μλ²λ₯Ό κ°κ° κ΄λ¦¬νλ©΄ API μ μκ° μ€λ³΅λ©λλ€. λ§μΆ€ν protoc νλ¬κ·ΈμΈμ μ¬μ©νλ©΄ λμΌν proto νμΌμ κΈ°μ€μΌλ‘ MCP μλ² μ½λλ₯Ό μμ±ν΄ νλμ μμ€μμ μ¬λ¬ μΈν°νμ΄μ€λ₯Ό κ΄λ¦¬ν μ μμ΅λλ€.
μ΄λ€ RPC λ©μλκ° MCP λκ΅¬λ‘ μμ±λλμ?
μ΄ νν 리μΌμμλ λ§μΆ€ν MCP μ΄λ Έν μ΄μ μ νμ±νν RPC λ©μλλ§ MCP λκ΅¬λ‘ μΆμΆν©λλ€. νλ¬κ·ΈμΈμ ν΄λΉ μ΄λ Έν μ΄μ κ³Ό HTTP μ 보λ₯Ό νμΈν΄ λꡬ μ΄λ¦, λ§€κ°λ³μ, μ€λͺ , μμ² λ°©μμ ꡬμ±ν©λλ€.
μμ±λ MCP μλ²λ REST APIμ μ΄λ»κ² ν΅μ νλμ?
μμ±λ Python MCP μλ²λ httpxλ₯Ό μ¬μ©ν΄ protoμ HTTP μ΄λ
Έν
μ΄μ
μμ μ»μ REST μλν¬μΈνΈλ₯Ό νΈμΆν©λλ€. GET, POST, PUT, DELETE, PATCH μμ²μ μ²λ¦¬νκ³ μλ΅μ JSON νμμΌλ‘ λ°νν©λλ€.
μ΄ νν 리μΌμ μ€ννλ €λ©΄ 무μμ΄ νμνκ°μ?
1λΆμ μμ νν λ¦¬μΌ νλ‘μ νΈμ ν¨κ» Go 1.19 μ΄μ, Protocol Buffer μ»΄νμΌλ¬(protoc), Python 3.8 μ΄μ, npxκ° νμν©λλ€. μμ±λ MCP μλ² ν
μ€νΈ λ¨κ³μμλ uv, fastmcp, httpx, MCP Inspectorλ₯Ό μ¬μ©ν©λλ€.
MCP μλ²κ° μμ±λμλμ§ μ΄λ»κ² νμΈνλμ?
generate.shλ₯Ό μ€νν λ€ MCP Inspectorμμ μλ²μ μ°κ²°νκ³ λꡬ λͺ©λ‘μ νμΈν©λλ€. μ΄ μμ μμλ get_bookκ³Ό create_bookμ΄ νμλλ©°, get_book μ€ν κ²°κ³Όλ₯Ό λμΌν REST API νΈμΆ κ²°κ³Όμ λΉκ΅ν μ μμ΅λλ€.
λ©μΌ: salesinquiry@enterprisedb.com
PostgreSQL λμ λΆν° μ΄μκΉμ§, EDBμ ν¨κ»νμΈμ
PostgreSQL λμ , μ΄μ, μ±λ₯ μ΅μ ν λ° μ κ·Έλ μ΄λμ λν΄ EDB μ λ¬Έκ°μ μλ΄ν΄ 보μΈμ.