mcpField
V
Vancouver

Vancouver

Local
github.com/jameslongDeveloper Tools38Updated 71w ago

About Vancouver

Vancouver is a simple Elixir library for adding MCP functionality to Phoenix or Bandit servers. It handles initialization and request validation and provides helpers for defining tools and prompts. The library is in early development and may include breaking changes.

Key features

  1. 01Adds an MCP route to Phoenix or Bandit servers
  2. 02Helper modules for defining tools and prompts
  3. 03Automatic initialization and request validation
  4. 04Synchronous responses only, no streaming

Use cases

  1. 01Exposing Elixir application tools to MCP clients
  2. 02Providing predefined prompts for tasks such as code review

MCP support

This project is a library for building MCP servers. It makes tools and prompts from an Elixir application available at an /mcp route to clients such as Claude Desktop. Only tools and prompts are currently supported.

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

CI Hex.pm Hexdocs.pm Hex.pm Hex.pm

Vancouver

Vancouver makes it easy to add Model Context Protocol (MCP) functionality to your Phoenix/Bandit server. Vancouver handles initialization, request validation, and offers helper functions to simplify the creation of MCP tools and prompts.

Getting started

1. Add dependency

In mix.exs:

defp deps do
  [
    {:vancouver, "~> 0.3"}
  ]
end
2. Create your tools/prompts

You can implement tools like this:

defmodule MyApp.Tools.CalculateSum do
  use Vancouver.Tool

  def name, do: "calculate_sum"
  def description, do: "Add two numbers together"

  def input_schema do
    %{
      "type" => "object",
      "properties" => %{
        "a" => %{"type" => "number"},
        "b" => %{"type" => "number"}
      },
      "required" => ["a", "b"]
    }
  end

  def run(conn, %{"a" => a, "b" => b}) do
    send_text(conn, "#{a + b}")
  end
end

And prompts like this:

defmodule MyApp.Prompts.CodeReview do
  use Vancouver.Prompt

  def name, do: "code_review"
  def description, do: "Asks the LLM to analyze code quality and suggest improvements"

  def arguments do
    [
      %{
        "name" => "code",
        "description" => "The code to review",
        "required" => true
      }
    ]
  end

  def run(conn, %{"code" => code}) do
    send_text(conn, "Please review this code: #{code}")
  end
end
3. Add config

In config.ex:

config :vancouver,
  name: "My MCP Server",
  version: "1.0.0"
4. Add your MCP route

In router.ex:

forward "/mcp", Vancouver.Router, 
  tools: [MyApp.Tools.CalculateSum],
  prompts: [MyApp.Prompts.CodeReview]
5. (Optional) Add to your MCP client

E.g. For Claude Desktop, you can modify your config Settings -> Developer -> Edit config as follows:

{
    "mcpServers": {
        "MyApp": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "http://localhost:4000/mcp"
            ]
        }
    }
}

Run your server, and restart Claude to starting using your MCP tools. 🚀

FAQ

Does Vancouver support all parts of the Model Context Protocol specification?

Not yet. Vancouver currently supports:

  • tools
  • prompts
  • sync responses (no streaming)

However, the library is simple enough that you should be able to modify it for your needs.

For more info on the protocol itself, see the MCP User Guide.

Is Vancouver stable / ready for production?

No. This library is in early development. Expect breaking changes.

Why is this library called Vancouver?

Vancouver is the natural home of MCP (Mountain, Coffee, and Phoenix).

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.