- Go 99.7%
- Shell 0.3%
| Filename | Latest commit message | Latest commit date |
|---|---|---|
1323fb5216
Implement the dispatcher middleware framework, allowing users to wrap method dispatching with their own code. The Dispatcher functions have an untyped params arg, but expect its value to be a typed, unmarshaled XXXParams struct. That required splitting the elegant dispatch[P, R] function into two parts, one to do the unmarshaling and one to call the method. The nicest way I could find to do that was to map from method names to a pair of functions, one to unmarshal and one to call. We could also write it as two switches on method name, which would require less machinery but would duplicate the list of method names, already a tad fragile because they are literal strings. I also exported the initialize params and result, so user Dispatchers could access them. All Params and Result types will have to be exported for that reason. Change-Id: Ie2c95cc17b4ef3d3d095dccdadb294e5f1590796 Reviewed-on: https://go-review.googlesource.com/c/tools/+/673515 Reviewed-by: Robert Findley <rfindley@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> |
||
| design | ||
| examples | ||
| internal | ||
| jsonschema | ||
| mcp | ||
| CONTRIBUTING.md | ||
| README.md | ||
MCP SDK prototype
The mcp package provides a software development kit (SDK) for writing clients and servers of the model context protocol. It is unstable, and will change in breaking ways in the future. As of writing, it is a prototype to explore the design space of client/server transport and binding.
Installation
The mcp package is currently internal and cannot be imported using go get.
Quickstart
Here's an example that creates a client that talks to an MCP server running as a sidecar process:
package main
import (
"context"
"log"
"os/exec"
"github.com/modelcontextprotocol/go-sdk/mcp"
)
func main() {
ctx := context.Background()
// Create a new client, with no features.
client := mcp.NewClient("mcp-client", "v1.0.0", nil)
// Connect to a server over stdin/stdout
transport := mcp.NewCommandTransport(exec.Command("myserver"))
session, err := client.Connect(ctx, transport)
if err != nil {
log.Fatal(err)
}
defer session.Close()
// Call a tool on the server.
if content, err := session.CallTool(ctx, "greet", map[string]any{"name": "you"}, nil); err != nil {
log.Printf("CallTool failed: %v", err)
} else {
log.Printf("CallTool returns: %v", content)
}
}
Here is an example of the corresponding server, connected over stdin/stdout:
package main
import (
"context"
"github.com/modelcontextprotocol/go-sdk/mcp"
)
type HiParams struct {
Name string `json:"name"`
}
func SayHi(ctx context.Context, cc *mcp.ServerSession, params *HiParams) ([]*mcp.Content, error) {
return []*mcp.Content{
mcp.NewTextContent("Hi " + params.Name),
}, nil
}
func main() {
// Create a server with a single tool.
server := mcp.NewServer("greeter", "v1.0.0", nil)
server.AddTools(mcp.NewTool("greet", "say hi", SayHi))
// Run the server over stdin/stdout, until the client diconnects
_ = server.Run(context.Background(), mcp.NewStdIOTransport())
}
Design
See design.md for the SDK design. That document is canonical: given any divergence between the design doc and this prototype, the doc reflects the latest design.
Testing
To test your client or server using stdio transport, you can use an in-memory transport. See example.
To test your client or server using sse transport, you can use the httptest package. See example.
Code of Conduct
This project follows the Go Community Code of Conduct. If you encounter a conduct-related issue, please mail conduct@golang.org.
License
Unless otherwise noted, the Go source files are distributed under the BSD-style license found in the LICENSE file.
Upon a potential move to the modelcontextprotocol organization, the license will be updated to the MIT License, and the license header will reflect the Go MCP SDK Authors.