Overview

The Frankfurter MCP Server is a lightweight adapter that exposes the Frankfurter currency exchange API as an MCP-compatible tool for language models and developer applications. It proxies and normalizes the public Frankfurter endpoints (latest rates, historical rates, supported currencies, conversion) and wraps them with a small HTTP server that serves tool metadata in the Model Context Protocol (MCP) format. This makes the exchange-rate functionality discoverable and callable by systems that integrate MCP tools or LLM toolkits.

By packaging the Frankfurter API behind an MCP endpoint, the server simplifies secure, consistent access to live FX data from applications, chatbots, or agent frameworks. It can reduce integration work for developers who want currency conversion or rate lookup tools available as first-class tools in an LLM environment, while optionally providing configuration points such as caching, base currency defaults, and deployment via Docker.

Features

MCP-compatible manifest and metadata for automated discovery by LLMs and tool orchestrators
Proxy endpoints for:
- Latest rates
- Historical rates by date
- Supported currency list
- On-the-fly currency conversion
Optional caching and base-currency defaults to reduce request load
Simple HTTP server with JSON responses and clear error handling
Docker-ready for containerized deployment
Minimal configuration via environment variables

Installation / Configuration

Prerequisites: Node.js (14+) or Docker.

Clone, install, and run locally:

git clone https://github.com/anirbanbasu/frankfurtermcp.git
cd frankfurtermcp
npm install
npm start

Environment variables (example .env):

PORT=8080
FRANKFURTER_BASE=https://api.frankfurter.app
CACHE_TTL_SECONDS=60
DEFAULT_BASE=EUR

Run with Node directly:

PORT=8080 node server.js

Build and run with Docker:

docker build -t frankfurter-mcp .
docker run -p 8080:8080 \
  -e FRANKFURTER_BASE=https://api.frankfurter.app \
  -e DEFAULT_BASE=EUR \
  frankfurter-mcp

Adjust CACHE_TTL_SECONDS or other environment settings to tune caching and performance.

Available Resources

The server exposes a small set of HTTP endpoints; most MCP deployments also provide a manifest endpoint that tools and LLMs can use to discover capabilities.

Common endpoints (example paths — adapt to your deployment prefix):

Path	Method	Description
/mcp/manifest or /.well-known/mcp	GET	MCP manifest / metadata describing available tools
/currencies	GET	Returns supported currency symbols and names
/latest	GET	Latest exchange rates (optional base query param)
/[YYYY-MM-DD]	GET	Historical rates for a specific date
/convert	GET	Convert amount between currencies (from, to, amount params)

Example: request supported currencies

curl http://localhost:8080/currencies

Example: convert 100 USD to EUR

curl "http://localhost:8080/convert?from=USD&to=EUR&amount=100"

Sample JSON response (converted):

{
  "amount": 100,
  "from": "USD",
  "to": "EUR",
  "date": "2026-04-09",
  "result": 92.34,
  "rate": 0.9234
}

The MCP manifest is typically a small JSON object listing available tools, their descriptions, input schemas, and call endpoints so an LLM can invoke them programmatically.

Use Cases

Chatbot currency assistant: Expose the MCP server to an LLM so users can ask “How much is 250 CAD in JPY?” and the model will call the /convert tool and return an accurate, live conversion.
Checkout pricing: Dynamically display product prices in a user’s preferred currency by calling /latest rates and applying conversions on the backend.
Financial reporting: Pull historical exchange rates for a given date range to normalize transactions or value foreign assets at historical rates.
Agent workflows: In multi-step LLM agent flows, use the MCP manifest to let the agent choose the currency conversion tool when planning steps involving monetary values.
Low-latency conversions: Use CACHE_TTL_SECONDS to reduce repeated external calls for frequently requested currency pairs, useful in high-throughput environments.

Example: Integrating with an LLM Tooling Layer

Point your tooling layer at the MCP manifest endpoint (e.g., https://example.com/.well-known/mcp).
The tooling layer reads available tools and registers a “convert” tool with the model.
When a user or agent needs conversion, the model issues an HTTP call to the server’s /convert endpoint with from/to/amount.
The MCP server returns a structured JSON result that the model or app can consume and present.

This server provides a simple, standard way to supply live exchange-rate data to applications and LLM-based systems that support MCP-style tool discovery and invocation.

Frankfurter MCP Server for Currency Exchange API