Resources

Resources are a core primitive in the Model Context Protocol (MCP) that allow servers to expose data and content that can be read by clients and used as context for LLM interactions.

MCP resources is a concept of MCP servers. Server should list resources when requested with method resources/list and retrieve when requested with method resources/read.

Servers also can provide dynamic resources using templates by listing them via resources/templates/list, however this feature is not yet supported in Foxy Contexts.

In Foxy Contexts there are two ways to include resources in your server:

  • using fxctx.NewResource to define static resources
  • using fxctx.NewResourceProvider to define resource providers

Approach with resource provider is more flexible and allows to provide resources dynamically, however all such resources would be still included in response for resources/list, in contrasts to concept of templates (which are not yet supported).

NewResource

In order to create new static resource you shall use fxctx.NewResource function.

examples/hello_world_resource/main.go 
func NewGreatResource() fxctx.Resource {
	return fxctx.NewResource(
		mcp.Resource{
			Name:        "hello-world",
			Uri:         "hello-world://hello-world",
			MimeType:    Ptr("application/json"),
			Description: Ptr("Hello World Resource"),
			Annotations: &mcp.ResourceAnnotations{
				Audience: []mcp.Role{
					mcp.RoleAssistant, mcp.RoleUser,
				},
			},
		},
		func(_ context.Context, uri string) (*mcp.ReadResourceResult, error) {
			return &mcp.ReadResourceResult{
				Contents: []interface{}{
					mcp.TextResourceContents{
						MimeType: Ptr("application/json"),
						Text:     `{"hello": "world"}`,
						Uri:      uri,
					},
				},
			}, nil
		},
	)
}

Register resources and start server

examples/hello_world_resource/main.go 
func main() {
	err := app.
		NewBuilder().
		// adding the resource to the app
		WithResource(NewGreatResource).
		// setting up server
		WithName("my-mcp-server").
		WithVersion("0.0.1").
		WithTransport(stdio.NewTransport()).
		// Configuring fx logging to only show errors
		WithFxOptions(
			fx.Provide(func() *zap.Logger {
				cfg := zap.NewDevelopmentConfig()
				cfg.Level.SetLevel(zap.ErrorLevel)
				logger, _ := cfg.Build()
				return logger
			}),
			fx.Option(fx.WithLogger(
				func(logger *zap.Logger) fxevent.Logger {
					return &fxevent.ZapLogger{Logger: logger}
				},
			)),
		).Run()

	if err != nil {
		log.Fatal(err)
	}
}

NewResourceProvider

In order to create new resource provider that would be returning resources dynamically, you shall use fxctx.NewResourceProvider function. It would then take two functions - one in order to list resources and another to read them.

examples/resource_provider/main.go 
func NewGreatResourceProvider() fxctx.ResourceProvider {
	return fxctx.NewResourceProvider(
		// This is the callback that would be executed when the resources/list is requested:
		func(_ context.Context) ([]mcp.Resource, error) {
			return []mcp.Resource{
				{
					Name:        "my-great-resource-one",
					Description: Ptr("Does something great"),
					Uri:         "/resources/great/one",
				},
			}, nil
		},
		//  This function reads the resource for a given uri to run when resources/read is requested:
		func(_ context.Context, uri string) (*mcp.ReadResourceResult, error) {

			// you would probably be doing something more complicated here
			// like reading from a database or calling an external service
			// based on what you have parsed from the uri
			if uri == "/resources/great/one" {
				return &mcp.ReadResourceResult{
					Contents: []interface{}{
						mcp.TextResourceContents{
							MimeType: Ptr("application/json"),
							Text:     string(`{"great": "resource"}`),
							Uri:      uri,
						},
					},
				}, nil
			}

			// this error would be wrapped in JSON-RPC error response
			return nil, fmt.Errorf("resource not found")
		},
	)
}

Examples

Check out complete examples of MCP Servers with resources:

ToolsPrompts