mcpField
Q
Qilin MCP Framework 🌩️🐲🌩️

Qilin MCP Framework 🌩️🐲🌩️

Local
github.com/miyamo2Developer Tools2Updated 72w ago

About Qilin MCP Framework 🌩️🐲🌩️

Qilin is a Go framework for building Model Context Protocol servers. It offers a zero-configuration startup, handler patterns familiar to Go web developers, and both stdio and Streamable HTTP transports.

Key features

  1. 01Zero-configuration server startup
  2. 02Stdio and Streamable HTTP transports
  3. 03Tool listing and calling
  4. 04Resource listing and reading
  5. 05Middleware for tools and resources
  6. 06Resource templates and subscriptions

Use cases

  1. 01Start a Go MCP server with minimal setup
  2. 02Expose tools through a Go application
  3. 03Serve resources and resource templates
  4. 04Add middleware to tool or resource handlers

MCP support

Qilin is a Go framework for implementing MCP servers. It supports stdio and Streamable HTTP, and provides tools, resources, templates, subscriptions, and middleware; prompt support is listed as unimplemented.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

No install method listed yet

We haven’t collected a package or remote endpoint for this server. Follow the instructions in the project README.

Repository

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

Qilin Logo

Qilin 🌩️🐲🌩️ – Model Context Protocol Framework for Go

Go Reference Go Version Go Report Card License MIT Status WIP Ask DeepWiki Ask DeepWiki

🌟 Highlights

  
⚡ Zero‑config serverqilin.New().Start() launches an MCP server on STDIN/STDOUT
🤝 Familiar look and feelHandlers inspired by Go's well-known web application framework. Developers familiar with them will feel right at home.
⏩ Streamable HTTPSupports Streamable HTTP transport.

🚀 Quick Start

go get github.com/miyamo2/qilin
package main

import (
	"fmt"
	"github.com/miyamo2/qilin"
	"maps"
)

type OrderBeerRequest struct {
	BeerName string `json:"beer_name" jsonschema:"title=Beer Name"`
	Quantity int    `json:"quantity"  jsonschema:"title=Quantity of Beers"`
}

type OrderBeerResponse struct {
	Amount float64 `json:"amount"`
}

var beers = map[string]string{
	"IPA":   "A hoppy beer with a bitter finish.",
	"Stout": "A dark beer with a rich, roasted flavor.",
	"Lager": "A light, crisp beer with a smooth finish.",
}

func main() {
	q := qilin.New("beer hall", qilin.WithVersion("v0.1.0"))

	q.Resource("menu_list",
		"resources://beer_list",
		func(c qilin.ResourceContext) error {
			return c.JSON(maps.Keys(beers))
		})

	q.Tool("order_beer",
		(*OrderBeerRequest)(nil),
		func(c qilin.ToolContext) error {
			var req OrderBeerRequest
			if err := c.Bind(&req); err != nil {
				return err
			}
			_, ok := beers[req.BeerName]
			if !ok {
				return fmt.Errorf("beer %s not found", req.BeerName)
			}
			amount := 8 * req.Quantity // Assume unit cost of all beers is $8.00.
			return c.JSON(OrderBeerResponse{Amount: float64(amount)})
		})
	q.Start() // listen on stdio
}

For more detailed usage, please refer to the Qilin User Guide.

🛤 Roadmap

Transports
  • Stdio
  • Streamable HTTP
Features
  • Tool
    • Listing
    • Calling
      • Middleware
  • Resource
    • Listing
    • Reading
      • Middleware
    • Templates
    • List Changed Notification
    • Subscriptions
  • Prompt

📜 License

Qilin released under the MIT License

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.