https://github.com/OkutaniDaichi0106/mcp-go
A library for establishing MCP server.
https://github.com/OkutaniDaichi0106/mcp-go
Last synced: 2 months ago
JSON representation
A library for establishing MCP server.
- Host: GitHub
- URL: https://github.com/OkutaniDaichi0106/mcp-go
- Owner: OkutaniDaichi0106
- License: mit
- Created: 2025-01-22T02:51:12.000Z (10 months ago)
- Default Branch: main
- Last Pushed: 2025-05-04T12:12:05.000Z (6 months ago)
- Last Synced: 2025-05-04T12:28:30.620Z (6 months ago)
- Language: Go
- Size: 33.2 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-mcp-servers - **mcp-go** - A library for establishing MCP server. `go` `mcp` `server` `go install OkutaniDaichi0106/mcp-go@latest` (⚙️ DevOps)
README
# MCP-Go
## What is MCP?
MCP (Model Context Protocol) is a lightweight, flexible protocol designed for efficient communication between AI models and applications. It provides a standardized way for services to exchange messages, tools, and resources while maintaining high performance and reliability.
## About this Package
MCP-Go is a Go implementation of the Model Context Protocol that provides a robust framework for AI communication:
- **Client-Server Architecture**: Complete implementation of both client and server components
- **Transport Flexibility**: Seamlessly communicate via Standard I/O, WebSockets, or HTTP
- **Concurrent Design**: Built from the ground up with Go's goroutines and channels
- **Type-Safe APIs**: Strong typing throughout the codebase to prevent runtime errors
- **Modular Components**: Handler-based design pattern for extensibility and maintainability
- **Session Management**: Persistent connections with proper lifecycle handling
## Usage
### Common Pattern
All MCP-Go implementations follow a similar pattern:
```go
package main
import (
"github.com/OkutaniDaichi0106/mcp-go/mcp"
)
func main() {
server := mcp.NewServer()
// Tool registration
mcp.HandleToolFunc(&mcp.ToolDefinition{
Name: "tool_name",
Description: "Tool description",
InputSchema: mcp.InputSchema(`{ "type": "object", ... }`),
}, func(w mcp.ContentsWriter, name string, args map[string]any) {
// Tool implementation
// ...
w.WriteContents(contents)
})
// Resource registration
mcp.HandleResourceFunc(&mcp.ResourceDefinition{
URI: "resource_uri",
MimeType: "resource_mime_type",
Name: "resource_name",
Description: "Resource description",
}, func(w mcp.ContentsWriter, uri string) {
// Resource implementation
// ...
w.WriteContents(contents)
})
// Prompt registration
mcp.HandlePromptFunc(&mcp.PromptDefinition{
Name: "prompt_name",
Description: "Prompt description",
InputSchema: mcp.InputSchema(`{ "type": "object", ... }`),
}, func(w mcp.PromptWriter, name string, args map[string]any) {
// Prompt implementation
// ...
w.WriteContents(contents)
})
transport, err := ... // Create transport
// Configure transport and accept -> get session
session, err := server.Accept(transport)
defer session.Close()
// ...
}
```
```go
package main
import (
"github.com/OkutaniDaichi0106/mcp-go/mcp"
)
func main() {
// Sample registration
mcp.HandleSampleFunc(&mcp.SampleDefinition{
Name: "sample_name",
Description: "Sample description",
}, func(w mcp.ContentsWriter, name string, args map[string]any) {
// Sample implementation
// ...
w.WriteContents(contents)
})
// Root registration
mcp.HandleRoot(&mcp.RootDefinition{
URI: "root_uri",
Name: "Root name",
})
// Create client
client := mcp.NewClient()
transport, err := ... // Create transport
// Configure transport and dial -> get session
session, err := client.Dial(transport)
defer session.Close()
// ...
}
```
### Transport Options
MCP-Go supports multiple transport methods with minimal code changes:
**Custom Transports**
For custom transports, use the `Accept` and `Dial` methods with the appropriate transport object.
```go
// Server
sess, err := server.Accept(t)
```
```go
// Client
sess, err := client.Dial(t)
```
**Standard I/O**
For Standard I/O, use the `AcceptStdio` and `DialStdio` methods.
```go
// Server
sess, err := server.AcceptStdio()
```
```go
// Client
sess, err := client.DialStdio("command", "arg1", "arg2")
```
**HTTP**
With HTTP, you can use the `AcceptHTTP` and `DialHTTP` methods.
```go
// Server
http.HandleFunc("/mcp", func(w http.ResponseWriter, r *http.Request) {
sess, err := server.AcceptHTTP(w, r)
})
```
```go
// Client
sess, err := client.DialHTTP("http://localhost:8080/mcp", nil)
```
## Specification Compliance
MCP-Go implements the [Model Context Protocol specification v2025-03-26](https://modelcontextprotocol.io/specification/2025-03-26), which is the latest version of the protocol as of this release.
## Installation
```bash
go get github.com/OkutaniDaichi0106/mcp-go
```
## Documentation
For detailed API documentation and advanced usage examples, please refer to our [GoDoc](https://godoc.org/github.com/OkutaniDaichi0106/mcp-go).
## License
This project is licensed under the MIT License - see the LICENSE file for details.