Foxy Contexts MCP Server

Getting Started with Foxy Contexts

Foxy Contexts is a Golang library for building Model Context Protocol (MCP) servers using a declarative approach. This guide will help you get started with setting up and using Foxy Contexts in your projects.

Installation

To use Foxy Contexts in your Go project, you need to install it using Go modules:

go get github.com/strowk/foxy-contexts

Basic Usage

Here's how to create a simple MCP server with Foxy Contexts:

1. Import the necessary packages:

import (
    "github.com/strowk/foxy-contexts/pkg/app"
    "github.com/strowk/foxy-contexts/pkg/fxctx"
    "github.com/strowk/foxy-contexts/pkg/mcp"
    "github.com/strowk/foxy-contexts/pkg/stdio"
    "go.uber.org/fx"
)

2. Define your tools, resources, or prompts:

// Example of defining a tool
func NewMyTool() fxctx.Tool {
    return fxctx.NewTool(
        &mcp.Tool{
            Name:        "my-tool",
            Description: Ptr("Description of my tool"),
            InputSchema: mcp.ToolInputSchema{
                Type:       "object",
                Properties: map[string]map[string]interface{}{
                    // Define your input properties here
                },
                Required: []string{},
            },
        },
        func(ctx context.Context, args map[string]interface{}) *mcp.CallToolResult {
            // Implement your tool logic here
            return &mcp.CallToolResult{
                Content: []interface{}{
                    mcp.TextContent{
                        Type: "text",
                        Text: "Result from my tool",
                    },
                },
            }
        },
    )
}

3. Create and run your MCP server:

func main() {
    builder := app.NewBuilder()
    
    // Register your tools, resources, or prompts
    builder.RegisterTool(NewMyTool)
    
    // Configure transports (stdio, SSE, or HTTP)
    builder.WithStdioTransport()
    
    // Build and run the application
    builder.Build().Run()
}

Available Transports

Foxy Contexts supports multiple transport mechanisms:

1. Stdio Transport: For command-line based interactions

   builder.WithStdioTransport()
   

2. SSE Transport: For Server-Sent Events

   builder.WithSSETransport()
   

3. HTTP Transport: For HTTP-based communication (beta)

   builder.WithHTTPTransport()
   

Testing Your MCP Server

Foxy Contexts provides a testing package called foxytest for functional testing:

import "github.com/strowk/foxy-contexts/pkg/foxytest"

func TestMyTool(t *testing.T) {
    tester := foxytest.NewTester(t)
    defer tester.Close()
    
    // Register your tool
    tester.RegisterTool(NewMyTool)
    
    // Test your tool
    result := tester.CallTool("my-tool", map[string]interface{}{
        // Tool arguments
    })
    
    // Assert on the result
    // ...
}

Advanced Features

Foxy Contexts supports various MCP features:

1. Resources: Define static or dynamic resources
2. Prompts: Create and complete prompts
3. Dependency Injection: Leverage Uber's fx for DI

Check the official documentation and examples for more detailed information on these features.