proto直接生成MCP-server：protoc-gen-go-mcp（1）

https://github.com/redpanda-data/protoc-gen-go-mcp

export GOSUMDB=sum.golang.org && go install github.com/redpanda-data/protoc-gen-go-mcp/cmd/protoc-gen-go-mcp@latest

%  ls $GOPATH/bin |grep mcp
protoc-gen-go-mcp

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
go install connectrpc.com/connect/cmd/protoc-gen-connect-go@latest
go install github.com/bufbuild/buf/cmd/buf@latest

buf config init

version: v2
managed:
  enabled: true
  override:
    - file_option: go_package_prefix
      value: learn/langchain/protoc_gen_mcp/exp2/gen/go
  disable:
    - file_option: go_package
      module: buf.build/googleapis/googleapis
plugins:
  # - remote: buf.build/protocolbuffers/go
  - local: protoc-gen-go
    out: ./gen/go
    opt: paths=source_relative
  # - remote: buf.build/grpc/go:v1.5.1
  - local: protoc-gen-go-grpc
    out: ./gen/go
    opt:
    - paths=source_relative
  # - remote: buf.build/connectrpc/go:v1.18.1
  - local: protoc-gen-connect-go
    out: ./gen/go
    opt:
    - paths=source_relative
  # - local: ["go","run","../protoc-gen-go-mcp/cmd/protoc-gen-go-mcp"]
  - local: protoc-gen-go-mcp
    out: ./gen/go
    opt: paths=source_relative

syntax = "proto3";
package example.v1;

message CreateExampleRequest {
  int32 some_int32 = 1;
  int64 some_int64 = 2;
  string some_string = 3;
  enum SomeEnum {
    SOME_ENUM_UNSPECIFIED = 0;
    SOME_ENUM_FIRST = 1;
    SOME_ENUM_SECOND = 2;
  }
  SomeEnum some_enum = 4;
  message Nested {
    string some_field = 1;
    message Nested2 {
      string some_nested_field = 1;
      message Nested3 {
        string some_nested_in_nested_field = 1;
        optional string optional_string = 2;
      }
      Nested3 nested3 = 2;
    }
    Nested2 nested2 = 2;
  }

  Nested nested = 5;
  optional string optional_string = 6;
  repeated string repeated_string = 7;
  map<string, Nested> map_with_nested_val = 8;
  map<int32, Nested> map_with_nested_val_no_string_key = 9;
  oneof some_oneof {
    string first_item = 10;
    int32 second_item = 11;
  }
}

message CreateExampleResponse {
  string some_string = 1;
}

service ExampleService {

  // @ignore-comment Ignore these linter rules, because we intentionally return a generic Operation message for all long-running operations.
  // buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
  // buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
  // CreateCluster create a Redpanda cluster. The input contains the spec, that describes the cluster.
  // A Operation is returned. This task allows the caller to find out when the long-running operation of creating a cluster has finished.
  rpc CreateExample(CreateExampleRequest) returns (CreateExampleResponse);
}

buf generate

.
|____go
| |____example
| | |____v1
| | | |____example_grpc.pb.go
| | | |____examplev1connect
| | | | |____example.connect.go
| | | |____examplev1mcp
| | | | |____example.pb.mcp.go
| | | |____example.pb.go

// Copyright 2025 Redpanda Data, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package main
import (
    "context"
    "fmt"
    examplev1 "learn/langchain/protoc_gen_mcp/exp2/gen/go/example/v1"
    "learn/langchain/protoc_gen_mcp/exp2/gen/go/example/v1/examplev1connect"
    "learn/langchain/protoc_gen_mcp/exp2/gen/go/example/v1/examplev1mcp"
    "github.com/mark3labs/mcp-go/server"
)
// Ensure our interface and the official gRPC interface are grpcClient
var (
    grpcClient examplev1.ExampleServiceClient
    mcpClient  = examplev1mcp.ExampleServiceClient(grpcClient)
)
// Ensure our interface and the official connect-go interface are compatible
var (
    connectClient    examplev1connect.ExampleServiceClient
    connectMcpClient = examplev1mcp.ConnectExampleServiceClient(connectClient)
)
func main() {
    // Create MCP server
    s := server.NewMCPServer(
        "Example auto-generated gRPC-MCP",
        "1.0.0",
    )
    srv := exampleServer{}
    examplev1mcp.RegisterExampleServiceHandler(s, &srv)
    if err := server.ServeStdio(s); err != nil {
        fmt.Printf("Server error: %v\n", err)
    }
}
type exampleServer struct {
}
func (t *exampleServer) CreateExample(ctx context.Context, in *examplev1.CreateExampleRequest) (*examplev1.CreateExampleResponse, error) {
    return &examplev1.CreateExampleResponse{
        SomeString: "HAHA " + in.GetNested().GetNested2().GetNested3().GetOptionalString(),
    }, nil
}

 % go build -o stdio main.go 
 % chmod +x stdio 
% ./stdio 

package main
import (
    "fmt"
    "log"
    "github.com/mark3labs/mcp-go/client"
    langchaingo_mcp_adapter "github.com/i2y/langchaingo-mcp-adapter"
)
func main() {
    // Create an MCP client using stdio
    mcpClient, err := client.NewStdioMCPClient(
        "./stdio", // Path to an MCP server
        nil,       // Additional environment variables if needed
    )
    if err != nil {
        log.Fatalf("Failed to create MCP client: %v", err)
    }
    defer mcpClient.Close()
    // Create the adapter
    adapter, err := langchaingo_mcp_adapter.New(mcpClient)
    if err != nil {
        log.Fatalf("Failed to create adapter: %v", err)
    }
    // Get all tools from MCP server
    mcpTools, err := adapter.Tools()
    if err != nil {
        log.Fatalf("Failed to get tools: %v", err)
    }
    for _, tool := range mcpTools {
        fmt.Println(tool.Name)
    }
}

go run mcp-client/stdio/main.go
0x91a4fc0
0x91a4fc0