MCP Go

https://pkg.go.dev/github.com/mathiasXie/mcp-go
Admin
MCP Go is a Go implementation of the Model Context Protocol that defines core types and interfaces...
Tokens:82,326
Snippets:758
Trust Score:9.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Run OAuth Client Example

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/examples/oauth_client

Execute the main Go program to start the OAuth client example. Ensure environment variables are set if required.

```bash
# Run the example
go run main.go
```

--------------------------------

### Initialize and Start an MCP Server

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go

Creates a new server instance and starts it using standard I/O for communication.

```go
// Create a basic server
s := server.NewMCPServer(
    "My Server",  // Server name
    "1.0.0",     // Version
)

// Start the server using stdio
if err := server.ServeStdio(s); err != nil {
    log.Fatalf("Server error: %v", err)
}
```

--------------------------------

### Start SSEServer

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Start begins serving SSE connections on the specified address, setting up necessary HTTP handlers.

```go
func (s *SSEServer) Start(addr string) error
```

--------------------------------

### Install mcp-go

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go

Command to install the mcp-go package via go get.

```bash
go get github.com/mathiasXie/mcp-go
```

--------------------------------

### InProcessTransport Start Method

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Starts the InProcessTransport. Returns an error if starting fails. Should only be called once.

```go
func (c *InProcessTransport) Start(ctx context.Context) error
```

--------------------------------

### Standalone Server Usage

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Example of creating and starting a StreamableHTTPServer as a standalone service. The server will listen on the specified address and expose the MCP endpoint.

```go
server := NewStreamableHTTPServer(mcpServer)
server.Start(":8080") // The final url for client is http://xxxx:8080/mcp by default
```

--------------------------------

### Initialize MCP Server

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcptest

Functions to create and start an MCP server instance for testing.

```go
func NewServer(t *testing.T, tools ...server.ServerTool) (*Server, error)
```

```go
func NewUnstartedServer(t *testing.T) *Server
```

--------------------------------

### Initialize an MCP Server

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go

Demonstrates the basic setup of an MCP server with a single tool handler using the mcp-go library.

```go
package main

import (
    "context"
    "errors"
    "fmt"

    "github.com/mathiasXie/mcp-go/mcp"
    "github.com/mathiasXie/mcp-go/server"
)

func main() {
    // Create a new MCP server
    s := server.NewMCPServer(
        "Demo 🚀",
        "1.0.0",
        server.WithToolCapabilities(false),
    )

    // Add tool
    tool := mcp.NewTool("hello_world",
        mcp.WithDescription("Say hello to someone"),
        mcp.WithString("name",
            mcp.Required(),
            mcp.Description("Name of the person to greet"),
        ),
    )

    // Add tool handler
    s.AddTool(tool, helloHandler)

    // Start the stdio server
    if err := server.ServeStdio(s); err != nil {
        fmt.Printf("Server error: %v\n", err)
    }
}

func helloHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
    name, err := request.RequireString("name")
    if err != nil {
        return mcp.NewToolResultError(err.Error()), nil
    }

    return mcp.NewToolResultText(fmt.Sprintf("Hello, %s!", name)), nil
}
```

--------------------------------

### Serve Stdio

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Starts a StdioServer using standard input and output with signal handling for graceful shutdown.

```go
func ServeStdio(server *MCPServer, opts ...StdioOption) error
```

--------------------------------

### Initialize the MCP client

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Negotiates with the server. Must be called after Start, and before any request methods.

```go
func (c *Client) Initialize(
	ctx context.Context,
	request mcp.InitializeRequest,
) (*mcp.InitializeResult, error)
```

--------------------------------

### Start StreamableHTTPServer

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Starts the StreamableHTTPServer, making it listen for incoming HTTP requests on the specified network address. The default endpoint path is '/mcp'.

```go
func (s *StreamableHTTPServer) Start(addr string) error
```

```go
s.Start(":8080")
```

--------------------------------

### Control Server Lifecycle

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcptest

Methods to interact with the server client, start the server, and clean up resources.

```go
func (s *Server) Client() *client.Client
```

```go
func (s *Server) Close()
```

```go
func (s *Server) Start(ctx context.Context) error
```

--------------------------------

### NewServer Function

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcptest

Initializes and starts a new MCP server instance for testing.

```APIDOC
## Function: NewServer

### Description
NewServer starts a new MCP server with the provided tools and returns the server instance.

### Signature
```go
func NewServer(t *testing.T, tools ...server.ServerTool) (*Server, error)
```

### Parameters
- **t** (*testing.T) - Required - The testing framework's T object.
- **tools** (...server.ServerTool) - Optional - A variadic list of server tools to initialize the server with.
```

--------------------------------

### Create a Calculator MCP Server

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go

A more complex example demonstrating a calculator tool with enum arguments and type-safe parameter access.

```go
package main

import (
    "context"
    "fmt"

    "github.com/mathiasXie/mcp-go/mcp"
    "github.com/mathiasXie/mcp-go/server"
)

func main() {
    // Create a new MCP server
    s := server.NewMCPServer(
        "Calculator Demo",
        "1.0.0",
        server.WithToolCapabilities(false),
        server.WithRecovery(),
    )

    // Add a calculator tool
    calculatorTool := mcp.NewTool("calculate",
        mcp.WithDescription("Perform basic arithmetic operations"),
        mcp.WithString("operation",
            mcp.Required(),
            mcp.Description("The operation to perform (add, subtract, multiply, divide)"),
            mcp.Enum("add", "subtract", "multiply", "divide"),
        ),
        mcp.WithNumber("x",
            mcp.Required(),
            mcp.Description("First number"),
        ),
        mcp.WithNumber("y",
            mcp.Required(),
            mcp.Description("Second number"),
        ),
    )

    // Add the calculator handler
    s.AddTool(calculatorTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
        // Using helper functions for type-safe argument access
        op, err := request.RequireString("operation")
        if err != nil {
            return mcp.NewToolResultError(err.Error()), nil
        }
        
        x, err := request.RequireFloat("x")
        if err != nil {
            return mcp.NewToolResultError(err.Error()), nil
        }
        
        y, err := request.RequireFloat("y")
        if err != nil {
            return mcp.NewToolResultError(err.Error()), nil
        }

        var result float64
        switch op {
        case "add":
            result = x + y
        case "subtract":
            result = x - y
        case "multiply":
            result = x * y
        case "divide":
            if y == 0 {
                return mcp.NewToolResultError("cannot divide by zero"), nil
            }
            result = x / y
        }

        return mcp.NewToolResultText(fmt.Sprintf("%.2f", result)), nil
    })

    // Start the server
    if err := server.ServeStdio(s); err != nil {
        fmt.Printf("Server error: %v\n", err)
    }
}
```

--------------------------------

### OnAfterInitializeFunc Type

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Callback function executed after initialization. Use for post-initialization setup.

```go
type OnAfterInitializeFunc func(ctx context.Context, id any, message *mcp.InitializeRequest, result *mcp.InitializeResult)
```

--------------------------------

### Create a new Stdio MCP client

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Creates a new stdio-based MCP client that communicates with a subprocess. It launches the specified command with given arguments and sets up stdin/stdout pipes for communication. Returns an error if the subprocess cannot be started or the pipes cannot be created. This function automatically starts the connection.

```go
func NewStdioMCPClient(
	command string,
	env []string,
	args ...string,
) (*Client, error)
```

--------------------------------

### Start SSE Connection

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Initiates the SSE connection and waits for server endpoint information. Errors occur if the connection fails or times out.

```go
func (c *SSE) Start(ctx context.Context) error
```

--------------------------------

### Registering MCP Prompts

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go

Examples of adding various prompt types to an MCP server, including simple greetings, code reviews with embedded resources, and database query builders.

```go
// Simple greeting prompt
s.AddPrompt(mcp.NewPrompt("greeting",
    mcp.WithPromptDescription("A friendly greeting prompt"),
    mcp.WithArgument("name",
        mcp.ArgumentDescription("Name of the person to greet"),
    ),
), func(ctx context.Context, request mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
    name := request.Params.Arguments["name"]
    if name == "" {
        name = "friend"
    }
    
    return mcp.NewGetPromptResult(
        "A friendly greeting",
        []mcp.PromptMessage{
            mcp.NewPromptMessage(
                mcp.RoleAssistant,
                mcp.NewTextContent(fmt.Sprintf("Hello, %s! How can I help you today?", name)),
            ),
        },
    ), nil
})

// Code review prompt with embedded resource
s.AddPrompt(mcp.NewPrompt("code_review",
    mcp.WithPromptDescription("Code review assistance"),
    mcp.WithArgument("pr_number",
        mcp.ArgumentDescription("Pull request number to review"),
        mcp.RequiredArgument(),
    ),
), func(ctx context.Context, request mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
    prNumber := request.Params.Arguments["pr_number"]
    if prNumber == "" {
        return nil, fmt.Errorf("pr_number is required")
    }
    
    return mcp.NewGetPromptResult(
        "Code review assistance",
        []mcp.PromptMessage{
            mcp.NewPromptMessage(
                mcp.RoleUser,
                mcp.NewTextContent("Review the changes and provide constructive feedback."),
            ),
            mcp.NewPromptMessage(
                mcp.RoleAssistant,
                mcp.NewEmbeddedResource(mcp.ResourceContents{
                    URI: fmt.Sprintf("git://pulls/%s/diff", prNumber),
                    MIMEType: "text/x-diff",
                }),
            ),
        },
    ), nil
})

// Database query builder prompt
s.AddPrompt(mcp.NewPrompt("query_builder",
    mcp.WithPromptDescription("SQL query builder assistance"),
    mcp.WithArgument("table",
        mcp.ArgumentDescription("Name of the table to query"),
        mcp.RequiredArgument(),
    ),
), func(ctx context.Context, request mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
    tableName := request.Params.Arguments["table"]
    if tableName == "" {
        return nil, fmt.Errorf("table name is required")
    }
    
    return mcp.NewGetPromptResult(
        "SQL query builder assistance",
        []mcp.PromptMessage{
            mcp.NewPromptMessage(
                mcp.RoleUser,
                mcp.NewTextContent("Help construct efficient and safe queries for the provided schema."),
            ),
            mcp.NewPromptMessage(
                mcp.RoleUser,
                mcp.NewEmbeddedResource(mcp.ResourceContents{
                    URI: fmt.Sprintf("db://schema/%s", tableName),
                    MIMEType: "application/json",
                }),
            ),
        },
    ), nil
})
```

--------------------------------

### Get Prompt Name

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Retrieve the name of a Prompt.

```go
func (p Prompt) GetName() string
```

--------------------------------

### Get server capabilities

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Returns the server capabilities supported by the MCP server.

```go
func (c *Client) GetServerCapabilities() mcp.ServerCapabilities
```

--------------------------------

### Get client capabilities

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Returns the client capabilities supported by the MCP client.

```go
func (c *Client) GetClientCapabilities() mcp.ClientCapabilities
```

--------------------------------

### Get prompt from the MCP server

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Retrieves a prompt from the MCP server.

```go
func (c *Client) GetPrompt(
	ctx context.Context,
	request mcp.GetPromptRequest,
) (*mcp.GetPromptResult, error)
```

--------------------------------

### NewUnstartedServer Function

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcptest

Creates a new MCP server instance without starting it, allowing for pre-start configuration.

```APIDOC
## Function: NewUnstartedServer

### Description
NewUnstartedServer creates a new MCP server instance with the given name, but does not start the server. Useful for tests where you need to add tools before starting the server.

### Signature
```go
func NewUnstartedServer(t *testing.T) *Server
```

### Parameters
- **t** (*testing.T) - Required - The testing framework's T object.
```

--------------------------------

### Create a new MCP client with Stdio transport

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Creates a new MCP client with the given transport. This example shows how to create a client using the Stdio transport.

```go
stdio := transport.NewStdio("./mcp_server", nil, "xxx")
client, err := NewClient(stdio)
if err != nil {
    log.Fatalf("Failed to create client: %v", err)
}
```

--------------------------------

### Integrate Custom HTTP Server with SSE

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

WithHTTPServer sets the HTTP server instance. Note: When providing a custom HTTP server, you must handle routing yourself. If routing is not set up, the server will start but won't handle any MCP requests.

```go
func WithHTTPServer(srv *http.Server) SSEOption
```

--------------------------------

### Integration with Existing HTTP Server

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Example of integrating StreamableHTTPServer as an http.Handler into an existing Go http server. This allows for more advanced routing and middleware configurations.

```go
handler := NewStreamableHTTPServer(mcpServer)
http.Handle("/streamable-http", handler)
http.ListenAndServe(":8080", nil)
```

--------------------------------

### Set Environment Variables for OAuth Client

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/examples/oauth_client

Set these environment variables before running the OAuth client example. They are optional but recommended for configuring client ID and secret.

```bash
# Set environment variables (optional)
export MCP_CLIENT_ID=your_client_id
export MCP_CLIENT_SECRET=your_client_secret
```

--------------------------------

### GET /mcp (SSE Stream)

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

The GET endpoint is used for establishing SSE streams for server-to-client communication.

```APIDOC
## GET /mcp

### Description
Establishes a Server-Sent Events (SSE) connection for the MCP session.

### Method
GET

### Endpoint
/mcp

### Response
#### Success Response (200)
- **Content-Type** (string) - text/event-stream
```

--------------------------------

### Manage Server Components

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcptest

Methods to register prompts, resources, and tools to an unstarted server instance.

```go
func (s *Server) AddPrompt(prompt mcp.Prompt, handler server.PromptHandlerFunc)
```

```go
func (s *Server) AddPrompts(prompts ...server.ServerPrompt)
```

```go
func (s *Server) AddResource(resource mcp.Resource, handler server.ResourceHandlerFunc)
```

```go
func (s *Server) AddResourceTemplate(template mcp.ResourceTemplate, handler server.ResourceTemplateHandlerFunc)
```

```go
func (s *Server) AddResourceTemplates(templates ...ServerResourceTemplate)
```

```go
func (s *Server) AddResources(resources ...server.ServerResource)
```

```go
func (s *Server) AddTool(tool mcp.Tool, handler server.ToolHandlerFunc)
```

```go
func (s *Server) AddTools(tools ...server.ServerTool)
```

--------------------------------

### Create New Prompt

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Initialize a new Prompt with a name and optional prompt options.

```go
func NewPrompt(name string, opts ...PromptOption) Prompt
```

--------------------------------

### Set Heartbeat Interval

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Sets the heartbeat interval. A positive interval means the server will send a heartbeat to the client through the GET connection to keep the connection alive. If the client does not establish a GET connection, it has no effect. The default is not to send heartbeats.

```go
func WithHeartbeatInterval(interval time.Duration) StreamableHTTPOption
```

--------------------------------

### Listen for JSON-RPC Messages

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Starts listening for JSON-RPC messages on the provided input and writes responses to the provided output. It runs until the context is cancelled or an error occurs. Returns an error if there are issues with reading input or writing output.

```go
func (s *StdioServer) Listen(
	ctx context.Context,
	stdin io.Reader,
	stdout io.Writer,
) error
```

--------------------------------

### Get Resource Name

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

GetName returns the human-readable name of the resource.

```go
func (r Resource) GetName() string
```

--------------------------------

### Create New ListPromptsResult

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Build a ListPromptsResult containing a list of prompts and a cursor for pagination.

```go
func NewListPromptsResult(prompts []Prompt, nextCursor Cursor) *ListPromptsResult
```

--------------------------------

### Get RequestId Value

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Value returns the underlying serializable value of the RequestId.

```go
func (r RequestId) Value() any
```

--------------------------------

### SSEServer.Start

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Begins serving SSE connections on the specified network address.

```APIDOC
## POST /start

### Description
Initiates the SSE server, making it listen for and accept incoming connections on the specified network address. It configures the necessary HTTP handlers for SSE and message endpoints.

### Method
POST

### Endpoint
/start

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **addr** (string) - Required - The network address (e.g., ":8080") on which the server will listen.

### Request Example
```go
err := sseServer.Start(":8080")
if err != nil {
    // Handle error during startup
}
```

### Response
#### Success Response (200)
Indicates the server has started successfully.

#### Response Example
```json
{
  "status": "server started",
  "address": ":8080"
}
```

#### Error Response (e.g., 500)
- **error** (string) - Description of the error encountered during startup (e.g., address already in use).
```

--------------------------------

### Implement Basic Session Handling

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go

Create and register a custom session by implementing the ClientSession interface to manage notifications and session state.

```go
// Create a server with session capabilities
s := server.NewMCPServer(
    "Session Demo",
    "1.0.0",
    server.WithToolCapabilities(true),
)

// Implement your own ClientSession
type MySession struct {
    id           string
    notifChannel chan mcp.JSONRPCNotification
    isInitialized bool
    // Add custom fields for your application
}

// Implement the ClientSession interface
func (s *MySession) SessionID() string {
    return s.id
}

func (s *MySession) NotificationChannel() chan<- mcp.JSONRPCNotification {
    return s.notifChannel
}

func (s *MySession) Initialize() {
    s.isInitialized = true
}

func (s *MySession) Initialized() bool {
    return s.isInitialized
}

// Register a session
session := &MySession{
    id:           "user-123",
    notifChannel: make(chan mcp.JSONRPCNotification, 10),
}
if err := s.RegisterSession(context.Background(), session); err != nil {
    log.Printf("Failed to register session: %v", err)
}

// Send notification to a specific client
err := s.SendNotificationToSpecificClient(
    session.SessionID(),
    "notification/update",
    map[string]any{"message": "New data available!"},
)
if err != nil {
    log.Printf("Failed to send notification: %v", err)
}

// Unregister session when done
s.UnregisterSession(context.Background(), session.SessionID())
```

--------------------------------

### Prompt Option: With Prompt Description

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Create a PromptOption to set the description for a prompt.

```go
func WithPromptDescription(description string) PromptOption
```

--------------------------------

### Create Test Servers

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Helper functions to instantiate test servers for MCPServer instances.

```go
func NewTestServer(server *MCPServer, opts ...SSEOption) *httptest.Server
```

```go
func NewTestStreamableHTTPServer(server *MCPServer, opts ...StreamableHTTPOption) *httptest.Server
```

--------------------------------

### Set Resource Description

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Use `WithResourceDescription` to add a human-readable explanation for a `Resource`. This aids in understanding the resource's purpose.

```go
func WithResourceDescription(description string) ResourceOption
```

--------------------------------

### Create New GetPromptResult

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Construct a new GetPromptResult with a description and a list of prompt messages.

```go
func NewGetPromptResult(description string, messages []PromptMessage) *GetPromptResult
```

--------------------------------

### Get ResourceTemplate Name

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

The `GetName` method returns the human-readable name associated with a `ResourceTemplate`.

```go
func (rt ResourceTemplate) GetName() string
```

--------------------------------

### OAuth Handler Initialization

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Demonstrates how to create a new OAuthHandler with the necessary configuration.

```APIDOC
## NewOAuthHandler

### Description
Creates a new OAuth handler with the provided configuration.

### Signature
```go
func NewOAuthHandler(config OAuthConfig) *OAuthHandler
```

### Parameters
#### Request Body
- **config** (*OAuthConfig*) - Required - The OAuth configuration object.

### Response Example
```json
{
  "handler": "*OAuthHandler"
}
```
```

--------------------------------

### Get Tool Name

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

GetName is a method on the Tool struct that returns the tool's name.

```go
func (t Tool) GetName() string
```

--------------------------------

### Get SSE Endpoint URL

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Returns the current endpoint URL used for the SSE connection.

```go
func (c *SSE) GetEndpoint() *url.URL
```

--------------------------------

### Initialize Memory Token Store

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Convenience wrapper for creating a memory-based token store.

```go
var NewMemoryTokenStore = transport.NewMemoryTokenStore
```

--------------------------------

### Get SSE Base URL

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Retrieves the base URL that was configured when the SSE client was initialized.

```go
func (c *SSE) GetBaseURL() *url.URL
```

--------------------------------

### Enable Server Logging

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

WithLogging enables logging capabilities for the server.

```go
func WithLogging() ServerOption
```

--------------------------------

### Initialization Structures and Helpers

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Defines the request, response, and notification structures for the MCP initialization handshake.

```go
type InitializeParams struct {
	// The latest version of the Model Context Protocol that the client supports.
	// The client MAY decide to support older versions as well.
	ProtocolVersion string             `json:"protocolVersion"`
	Capabilities    ClientCapabilities `json:"capabilities"`
	ClientInfo      Implementation     `json:"clientInfo"`
}
```

```go
type InitializeRequest struct {
	Request
	Params InitializeParams `json:"params"`
}
```

```go
type InitializeResult struct {
	Result
	// The version of the Model Context Protocol that the server wants to use.
	// This may not match the version that the client requested. If the client cannot
	// support this version, it MUST disconnect.
	ProtocolVersion string             `json:"protocolVersion"`
	Capabilities    ServerCapabilities `json:"capabilities"`
	ServerInfo      Implementation     `json:"serverInfo"`
	// Instructions describing how to use the server and its features.
	//
	// This can be used by clients to improve the LLM's understanding of
	// available tools, resources, etc. It can be thought of like a "hint" to the model.
	// For example, this information MAY be added to the system prompt.
	Instructions string `json:"instructions,omitempty"`
}
```

```go
func NewInitializeResult(
	protocolVersion string,
	capabilities ServerCapabilities,
	serverInfo Implementation,
	instructions string,
) *InitializeResult
```

```go
type InitializedNotification struct {
	Notification
}
```

--------------------------------

### Get Prompt Request

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

The GetPromptRequest is used by the client to retrieve a specific prompt or prompt template from the server.

```APIDOC
## GetPromptRequest

### Description
Used by the client to get a prompt provided by the server.

### Request Body
- **name** (string) - Required - The name of the prompt or prompt template.
- **arguments** (map[string]string) - Optional - Arguments to use for templating the prompt.

### Request Example
{
  "params": {
    "name": "summarize-text",
    "arguments": {
      "length": "short"
    }
  }
}

### Response
#### Success Response (200)
- **description** (string) - Optional - An optional description for the prompt.
- **messages** ([]PromptMessage) - Required - The list of messages associated with the prompt.
```

--------------------------------

### Get SSE OAuth Handler

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Retrieves the configured OAuth handler, if one has been set for the SSE client.

```go
func (c *SSE) GetOAuthHandler() *OAuthHandler
```

--------------------------------

### Create New StdioServer

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Creates a new stdio server wrapper around an MCPServer. It initializes the server with a default error logger that discards all output.

```go
func NewStdioServer(server *MCPServer) *StdioServer
```

--------------------------------

### Prompt Option: With Argument

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Create a PromptOption that includes an argument with its own options.

```go
func WithArgument(name string, opts ...ArgumentOption) PromptOption
```

--------------------------------

### Initialization and Capabilities

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Types related to initializing the server and its capabilities.

```APIDOC
## Initialization and Capabilities

### Types
- `InitializeParams`
- `InitializeRequest`
- `InitializeResult`
- `InitializedNotification`
- `ServerCapabilities`

### Functions
- `NewInitializeResult(protocolVersion string, capabilities ServerCapabilities, ...) *InitializeResult`: Creates a new InitializeResult.
```

--------------------------------

### Transport Interface

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Defines the interface for the transport layer, outlining methods for starting, sending requests/notifications, handling notifications, and closing the connection.

```APIDOC
## Interface

### Description
Interface for the transport layer. Defines the contract for communication mechanisms.

### Methods
#### Start
- **Description**: Starts the connection. Should only be called once.
- **Signature**: `Start(ctx context.Context) error`

#### SendRequest
- **Description**: Sends a JSON-RPC request and returns the response synchronously.
- **Signature**: `SendRequest(ctx context.Context, request JSONRPCRequest) (*JSONRPCResponse, error)`

#### SendNotification
- **Description**: Sends a JSON-RPC Notification to the server.
- **Signature**: `SendNotification(ctx context.Context, notification mcp.JSONRPCNotification) error`

#### SetNotificationHandler
- **Description**: Sets the handler for notifications. Any notification received before the handler is set will be discarded.
- **Signature**: `SetNotificationHandler(handler func(notification mcp.JSONRPCNotification))`

#### Close
- **Description**: Closes the connection.
- **Signature**: `Close() error`

### Request Example
```go
// Example of using the interface (assuming 'transport' is an implementation)
var transport Interface
transport.Start(ctx)
response, err := transport.SendRequest(ctx, myRequest)
transport.SendNotification(ctx, myNotification)
transport.SetNotificationHandler(myHandler)
transport.Close()
```

### Response
#### Success Response (Varies by method)
- **Start**: `nil` on success, `error` on failure.
- **SendRequest**: `*JSONRPCResponse` and `nil` error on success, `nil` response and `error` on failure.
- **SendNotification**: `nil` error on success, `error` on failure.
- **SetNotificationHandler**: No return value.
- **Close**: `nil` error on success, `error` on failure.

#### Response Example
```go
// Success examples depend on the specific method called.
// For SendRequest: &JSONRPCResponse{...}, nil
// For Start, SendNotification, Close: nil
```
```

--------------------------------

### Create New InitializeResult

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Construct a new InitializeResult, requiring protocol version, server capabilities, and other options.

```go
func NewInitializeResult(protocolVersion string, capabilities ServerCapabilities, ...) *InitializeResult
```

--------------------------------

### Get the stderr reader for the subprocess

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Returns a reader for the stderr output of the subprocess. This can be used to capture error messages or logs from the subprocess.

```go
func GetStderr(c *Client) (io.Reader, bool)
```

--------------------------------

### Transport Interface

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Defines the interface for the transport layer in MCP, including methods for starting, sending requests/notifications, setting handlers, and closing connections.

```go
type Interface interface {
	// Start the connection. Start should only be called once.
	Start(ctx context.Context) error

	// SendRequest sends a json RPC request and returns the response synchronously.
	SendRequest(ctx context.Context, request JSONRPCRequest) (*JSONRPCResponse, error)

	// SendNotification sends a json RPC Notification to the server.
	SendNotification(ctx context.Context, notification mcp.JSONRPCNotification) error

	// SetNotificationHandler sets the handler for notifications.
	// Any notification before the handler is set will be discarded.
	SetNotificationHandler(handler func(notification mcp.JSONRPCNotification))

	// Close the connection.
	Close() error
}
```

--------------------------------

### Configure Prompt Capabilities

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

WithPromptCapabilities configures server capabilities related to prompts, specifically indicating if a list has changed.

```go
func WithPromptCapabilities(listChanged bool) ServerOption
```

--------------------------------

### Get URL Path from Input String

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

GetUrlPath processes an input string to derive a URL path, returning the path and any potential errors.

```go
func (s *SSEServer) GetUrlPath(input string) (string, error)
```

--------------------------------

### Create New ListPromptsResult

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Creates a new ListPromptsResult with the given prompts and next cursor for pagination. Use this to construct the server's response to a prompt listing request.

```go
func NewListPromptsResult(
	prompts []Prompt,
	nextCursor Cursor,
) *ListPromptsResult
```

--------------------------------

### Get the underlying transport layer

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Gives access to the underlying transport layer. Cast it to the specific transport type to obtain helper methods.

```go
func (c *Client) GetTransport() transport.Interface
```

--------------------------------

### StdioServer Configuration Options

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Functions to configure the StdioServer.

```APIDOC
## StdioServer Configuration Options

### Description
Functions to configure the StdioServer.

#### WithErrorLogger(logger *log.Logger) StdioOption
Sets the error logger for the server.

#### WithStdioContextFunc(fn StdioContextFunc) StdioOption
Sets a function that will be called to customise the context to the server. Note that the stdio server uses the same context for all requests, so this function will only be called once per server instance.
```

--------------------------------

### Configure SSE Server with Dynamic Base Path Function

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

WithDynamicBasePath accepts a function for generating the base path. This is useful when the base path is not known at SSE server creation time, such as with a reverse proxy or dynamic mounting.

```go
func WithDynamicBasePath(fn DynamicBasePathFunc) SSEOption
```

--------------------------------

### Define and Use OnErrorHookFunc

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Defines the error hook signature and provides an example of handling specific error types using errors.Is and errors.As.

```go
type OnErrorHookFunc func(ctx context.Context, id any, method mcp.MCPMethod, message any, err error)
```

```go
hooks.AddOnError(func(ctx context.Context, id any, method mcp.MCPMethod, message any, err error) {
  // Check for specific error types using errors.Is
  if errors.Is(err, ErrUnsupported) {
    // Handle capability not supported errors
    log.Printf("Capability not supported: %v", err)
  }

  // Use errors.As to get specific error types
  var parseErr = &UnparsableMessageError{}
  if errors.As(err, &parseErr) {
    // Access specific methods/fields of the error type
    log.Printf("Failed to parse message for method %s: %v",
               parseErr.GetMethod(), parseErr.Unwrap())
    // Access the raw message that failed to parse
    rawMsg := parseErr.GetMessage()
  }

  // Check for specific resource/prompt/tool errors
  switch {
  case errors.Is(err, ErrResourceNotFound):
    log.Printf("Resource not found: %v", err)
  case errors.Is(err, ErrPromptNotFound):
    log.Printf("Prompt not found: %v", err)
  case errors.Is(err, ErrToolNotFound):
    log.Printf("Tool not found: %v", err)
  }
})
```

--------------------------------

### Create New MCP Server

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Creates a new MCP server instance, requiring a name and version, and accepting optional server options.

```go
func NewMCPServer(
	name, version string,
	opts ...ServerOption,
) *MCPServer
```

--------------------------------

### Define Root struct for server-accessible resources

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

The Root struct identifies a file or directory accessible by the server. The URI must start with 'file://' for now.

```go
type Root struct {
	// The URI identifying the root. This *must* start with file:// for now.
	// This restriction may be relaxed in future versions of the protocol to allow
	// other URI schemes.
	URI string `json:"uri"`
	// An optional name for the root. This can be used to provide a human-readable
	// identifier for the root, which may be useful for display purposes or for
	// referencing the root in other parts of the application.
	Name string `json:"name,omitempty"`
}
```

--------------------------------

### Retrieve Integer Argument from CallToolRequest

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Use RequireInt to get an integer argument by its key. Returns an error if the key is not found or the value cannot be converted to an integer.

```go
func (r CallToolRequest) RequireInt(key string) (int, error)
```

--------------------------------

### Configure OAuth Client

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Configuration structure for OAuth 2.0 clients.

```go
type OAuthConfig struct {
	// ClientID is the OAuth client ID
	ClientID string
	// ClientSecret is the OAuth client secret (for confidential clients)
	ClientSecret string
	// RedirectURI is the redirect URI for the OAuth flow
	RedirectURI string
	// Scopes is the list of OAuth scopes to request
	Scopes []string
	// TokenStore is the storage for OAuth tokens
	TokenStore TokenStore
	// AuthServerMetadataURL is the URL to the OAuth server metadata
	// If empty, the client will attempt to discover it from the base URL
	AuthServerMetadataURL string
	// PKCEEnabled enables PKCE for the OAuth flow (recommended for public clients)
	PKCEEnabled bool
}
```

--------------------------------

### Add Multiple Prompts

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Registers multiple prompt handlers at once using a variadic argument list of ServerPrompt.

```go
func (s *MCPServer) AddPrompts(prompts ...ServerPrompt)
```

--------------------------------

### GetPrompt Structures and Helpers

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Defines the request and response structures for retrieving prompts, along with creation and parsing helpers.

```go
type GetPromptParams struct {
	// The name of the prompt or prompt template.
	Name string `json:"name"`
	// Arguments to use for templating the prompt.
	Arguments map[string]string `json:"arguments,omitempty"`
}
```

```go
type GetPromptRequest struct {
	Request
	Params GetPromptParams `json:"params"`
}
```

```go
type GetPromptResult struct {
	Result
	// An optional description for the prompt.
	Description string          `json:"description,omitempty"`
	Messages    []PromptMessage `json:"messages"`
}
```

```go
func NewGetPromptResult(
	description string,
	messages []PromptMessage,
) *GetPromptResult
```

```go
func ParseGetPromptResult(rawMessage *json.RawMessage) (*GetPromptResult, error)
```

--------------------------------

### Set Endpoint Path for Server

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Sets the endpoint path for the server. The default is "/mcp". It only works for the `Start` method. When used as a http.Handler, it has no effect.

```go
func WithEndpointPath(endpointPath string) StreamableHTTPOption
```

--------------------------------

### Get the current endpoint URL for SSE connection

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Returns the current endpoint URL for the SSE connection. This method only works with SSE transport; otherwise, it will panic.

```go
func GetEndpoint(c *Client) *url.URL
```

--------------------------------

### Define OnBeforeInitializeFunc

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Defines a hook function signature for processing InitializeRequest messages.

```go
type OnBeforeInitializeFunc func(ctx context.Context, id any, message *mcp.InitializeRequest)
```

--------------------------------

### Create New PromptMessage

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Construct a PromptMessage with a role and content.

```go
func NewPromptMessage(role Role, content Content) PromptMessage
```

--------------------------------

### WithHeaders Option

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Configures the SSE client with a map of static HTTP headers.

```go
func WithHeaders(headers map[string]string) ClientOption
```

--------------------------------

### Set HTTP Context Function

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Sets a function that will be called to customise the context to the server using the incoming request. This can be used to inject context values from headers, for example.

```go
func WithHTTPContextFunc(fn HTTPContextFunc) StreamableHTTPOption
```

--------------------------------

### Retrieve String Slice Argument from CallToolRequest

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Use RequireStringSlice to get a string slice argument by key. Errors are raised if the key is not found or the value is not convertible to a string slice.

```go
func (r CallToolRequest) RequireStringSlice(key string) ([]string, error)
```

--------------------------------

### Server Creation and Context

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Functions for creating and managing the MCP server instance and its context.

```APIDOC
## NewMCPServer

### Description
Creates a new MCP server instance with a given name and version.

### Method
`NewMCPServer`

### Parameters
- **name** (string) - Required - The name of the server.
- **version** (string) - Required - The version of the server.
- **opts** (...ServerOption) - Optional - Options to configure the server.

### ServerFromContext

### Description
Retrieves the MCPServer instance from a given context.

### Method
`ServerFromContext`

### Parameters
- **ctx** (context.Context) - Required - The context to retrieve the server from.

### WithContext

### Description
Returns a new context with the given client session associated with the server.

### Method
`WithContext`

### Parameters
- **ctx** (context.Context) - Required - The parent context.
- **session** (ClientSession) - Required - The client session to associate with the context.
```

--------------------------------

### Create New SSEServer Instance

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

NewSSEServer creates a new SSE server instance, requiring an MCP server and optional SSE options for configuration.

```go
func NewSSEServer(server *MCPServer, opts ...SSEOption) *SSEServer
```

--------------------------------

### Define ServerCapabilities for server features

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

ServerCapabilities outlines features a server supports, including experimental options, logging, prompts, resources, and tools. Capabilities are extensible.

```go
type ServerCapabilities struct {
	// Experimental, non-standard capabilities that the server supports.
	Experimental map[string]any `json:"experimental,omitempty"`
	// Present if the server supports sending log messages to the client.
	Logging *struct{} `json:"logging,omitempty"`
	// Present if the server offers any prompt templates.
	Prompts *struct {
		// Whether this server supports notifications for changes to the prompt list.
		ListChanged bool `json:"listChanged,omitempty"`
	} `json:"prompts,omitempty"`
	// Present if the server offers any resources to read.
	Resources *struct {
		// Whether this server supports subscribing to resource updates.
		Subscribe bool `json:"subscribe,omitempty"`
		// Whether this server supports notifications for changes to the resource
		// list.
		ListChanged bool `json:"listChanged,omitempty"`
	} `json:"resources,omitempty"`
	// Present if the server offers any tools to call.
	Tools *struct {
		// Whether this server supports notifications for changes to the tool list.
		ListChanged bool `json:"listChanged,omitempty"`
	} `json:"tools,omitempty"`
}
```

--------------------------------

### Get Message Endpoint URL for Client

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

GetMessageEndpointForClient returns the appropriate message endpoint URL with session ID for a given HTTP request. It handles dynamic/static paths and the UseFullURLForMessageEndpoint flag.

```go
func (s *SSEServer) GetMessageEndpointForClient(r *http.Request, sessionID string) string
```

--------------------------------

### Set StreamableHTTPServer Instance

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Sets the HTTP server instance for StreamableHTTPServer. NOTE: When providing a custom HTTP server, you must handle routing yourself. If routing is not set up, the server will start but won't handle any MCP requests.

```go
func WithStreamableHTTPServer(srv *http.Server) StreamableHTTPOption
```

--------------------------------

### Server Creation Functions

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Functions for creating test servers for the MCP-Go project.

```APIDOC
## NewTestServer

### Description
Creates a test server for testing purposes.

### Signature
```go
func NewTestServer(server *MCPServer, opts ...SSEOption) *httptest.Server
```

## NewTestStreamableHTTPServer

### Description
Creates a test server for testing purposes.

### Signature
```go
func NewTestStreamableHTTPServer(server *MCPServer, opts ...StreamableHTTPOption) *httptest.Server
```
```

--------------------------------

### WithOAuth Option

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Configures the SSE client with OAuth settings.

```go
func WithOAuth(config OAuthConfig) ClientOption
```

--------------------------------

### Create a new SSE MCP client

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Creates a new SSE-based MCP client with the given base URL. Returns an error if the URL is invalid.

```go
func NewSSEMCPClient(baseURL string, options ...transport.ClientOption) (*Client, error)
```

--------------------------------

### Configure client with HTTP client option

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Provides an option to set a custom HTTP client for the MCP client.

```go
func WithHTTPClient(httpClient *http.Client) transport.ClientOption
```

--------------------------------

### Configure Server with Hooks

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

WithHooks allows adding hooks to be called at various points in the request lifecycle, including before/after requests and before returning errors.

```go
func WithHooks(hooks *Hooks) ServerOption
```

--------------------------------

### Create New ListResourcesResult

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Create a ListResourcesResult containing a list of resources and a cursor for pagination.

```go
func NewListResourcesResult(resources []Resource, nextCursor Cursor) *ListResourcesResult
```

--------------------------------

### Create New Resource

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

NewResource creates a new Resource with a given URI and name, configured by optional ResourceOptions.

```go
func NewResource(uri string, name string, opts ...ResourceOption) Resource
```

--------------------------------

### Initialize SSE Transport

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client/transport

Creates a new SSE-based MCP client. Ensure the provided URL is valid. Options can be passed to customize client behavior.

```go
func NewSSE(baseURL string, options ...ClientOption) (*SSE, error)
```

--------------------------------

### Create New ImageContent

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcp

Initialize a new ImageContent with image data and its MIME type.

```go
func NewImageContent(data, mimeType string) ImageContent
```

--------------------------------

### Client Initialization

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/client

Methods for creating and configuring MCP clients using different transport layers.

```APIDOC
## NewStdioMCPClient

### Description
Creates a new stdio-based MCP client that communicates with a subprocess.

### Parameters
- **command** (string) - Required - The command to execute.
- **env** ([]string) - Required - Environment variables for the subprocess.
- **args** (...string) - Optional - Arguments for the command.

## NewSSEMCPClient

### Description
Creates a new SSE-based MCP client with the given base URL.

### Parameters
- **baseURL** (string) - Required - The base URL for the SSE connection.
- **options** (...transport.ClientOption) - Optional - Client configuration options.
```

--------------------------------

### Configure SSE Keep-Alive

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

WithKeepAlive configures whether to enable keep-alive for the SSE connection.

```go
func WithKeepAlive(keepAlive bool) SSEOption
```

--------------------------------

### Add Multiple Resources

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Registers multiple resource handlers at once using a variadic argument list of ServerResource.

```go
func (s *MCPServer) AddResources(resources ...ServerResource)
```

--------------------------------

### Define OnRequestInitializationFunc

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/server

Defines a function signature for pre-request initialization logic.

```go
type OnRequestInitializationFunc func(ctx context.Context, id any, message any) error
```

--------------------------------

### Server Methods

Source: https://pkg.go.dev/github.com/mathiasXie/mcp-go/mcptest

Methods for managing prompts, resources, tools, and the server lifecycle.

```APIDOC
## Methods for Server

### AddPrompt
Adds a prompt to an unstarted server.

#### Signature
```go
func (s *Server) AddPrompt(prompt mcp.Prompt, handler server.PromptHandlerFunc)
```

### AddPrompts
Adds multiple prompts to an unstarted server.

#### Signature
```go
func (s *Server) AddPrompts(prompts ...server.ServerPrompt)
```

### AddResource
Adds a resource to an unstarted server.

#### Signature
```go
func (s *Server) AddResource(resource mcp.Resource, handler server.ResourceHandlerFunc)
```

### AddResourceTemplate
Adds a resource template to an unstarted server.

#### Signature
```go
func (s *Server) AddResourceTemplate(template mcp.ResourceTemplate, handler server.ResourceTemplateHandlerFunc)
```

### AddResourceTemplates
Adds multiple resource templates to an unstarted server.

#### Signature
```go
func (s *Server) AddResourceTemplates(templates ...ServerResourceTemplate)
```

### AddResources
Adds multiple resources to an unstarted server.

#### Signature
```go
func (s *Server) AddResources(resources ...server.ServerResource)
```

### AddTool
Adds a tool to an unstarted server.

#### Signature
```go
func (s *Server) AddTool(tool mcp.Tool, handler server.ToolHandlerFunc)
```

### AddTools
Adds multiple tools to an unstarted server.

#### Signature
```go
func (s *Server) AddTools(tools ...server.ServerTool)
```

### Client
Returns an MCP client connected to the server.

#### Signature
```go
func (s *Server) Client() *client.Client
```

### Close
Stops the server and cleans up resources.

#### Signature
```go
func (s *Server) Close()
```

### Start
Starts the server in a goroutine.

#### Signature
```go
func (s *Server) Start(ctx context.Context) error
```
```
Tokens:
Raw