# Feather DB as a Claude Context Engine: The MCP Remote Backend

> Feather DB v0.14.0 ships feather-serve as an MCP server for Claude Desktop and Claude Code. Local .feather file or remote Cloud API — your agent now has persistent, semantic memory with 14 MCP tools.

- **Category**: Architecture
- **Read time**: 7 min read
- **Date**: June 16, 2026
- **Author**: Feather DB (Engineering)
- **URL**: https://getfeather.store/theory/feather-db-mcp-remote-backend-claude

---

## What v0.14.0 ships

Feather DB v0.14.0 introduces **feather-serve as an MCP server**. Connect it to Claude Desktop or Claude Code and your Claude instance gets a persistent, semantic context engine — 14 MCP tools covering search, add, link, context_chain traversal, and more. Works against a local `.feather` file or a remote Feather Cloud instance via `--api-url`.

v0.15.1 went further: added real embedders via `--embed-provider`, making persona recall fully semantic. Claude can now search your memory store using natural language — no manual embedding calls, no preprocessing pipeline.

## Why connect a database to an LLM via MCP?

Claude's context window resets every conversation. If you're building a coding assistant, a writing partner, a support agent, or any application where Claude should remember prior interactions, preferences, or knowledge — you need external memory.

The naive approach is to dump conversation history into the system prompt. That works for short sessions but breaks at scale: you hit token limits, costs multiply, and signal drowns in noise. A context engine retrieves only the relevant 5–10 memories, keeping prompts small and accurate.

MCP makes this connection first-class. Instead of wrapping memory calls in application code, Claude calls `feather_search` or `feather_context_chain` directly, mid-conversation, as a tool use.

## Setup in under 5 minutes

```bash
pip install feather-db

# Start feather-serve with Gemini embeddings (semantic recall)
GOOGLE_API_KEY=your-key feather-serve mypersona.feather \
  --embed-provider gemini --dim 768 --port 8001

```

Then add to your `claude_desktop_config.json` (macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "feather-persona": {
      "url": "http://localhost:8001/mcp"
    }
  }
}

```

Restart Claude Desktop. You'll see "feather-persona" appear in the MCP tools list. Claude can now call `feather_search`, `feather_add`, and 12 other tools against your local context store.

## The 14 MCP tools

ToolDescription

`feather_search`ANN semantic search over the store
`feather_add`Add a memory node (text embedded by feather-serve)
`feather_link`Add a typed edge between two nodes
`feather_context_chain`Semantic search + BFS graph traversal in one call
`feather_get`Retrieve a node by ID
`feather_delete`Remove a node and its edges
`feather_keyword_search`BM25 keyword search
`feather_batch_add`Add multiple nodes in parallel
`feather_set_metadata`Update node attributes
`feather_get_metadata`Read node attributes
`feather_list_edges`List edges for a node
`feather_graph_stats`Count nodes, edges, namespaces
`feather_list_namespaces`Show all namespaces in the store
`feather_health`Liveness check

## Real embedders: what --embed-provider changes

Without `--embed-provider`, `feather_add` requires a pre-embedded vector — you'd need to call an embedding API yourself before calling the tool. With `--embed-provider gemini` (or openai, voyage, cohere, ollama), feather-serve embeds text automatically inside the MCP call. You pass raw text; Feather handles the rest.

```bash
# Gemini — 768-dim, native Feather format, $0/1M tokens in free tier
GOOGLE_API_KEY=… feather-serve agent.feather \
  --embed-provider gemini --dim 768

# OpenAI — text-embedding-3-small, 1536-dim
OPENAI_API_KEY=… feather-serve agent.feather \
  --embed-provider openai --dim 1536

# Fully offline
feather-serve agent.feather \
  --embed-provider ollama --ollama-model nomic-embed-text --dim 1024

```

With real embedders, `feather_search` also accepts raw text queries — feather-serve embeds the query before searching. Claude doesn't need to know anything about embedding dimensions or models.

## Connecting to Feather Cloud

For teams running Feather Cloud, the setup is identical except you point `--api-url` at your hosted instance:

```bash
feather-serve --api-url https://your-cloud.example.com \
  --embed-provider gemini --dim 768 --port 8001

```

This proxies MCP calls through `feather-serve` to the Cloud API, giving Claude the same 14 tools against a hosted, multi-tenant context store.

## What this enables

A Claude instance with Feather DB MCP has persistent, evolving memory across conversations. In practice:

- **Coding assistant**: Claude remembers your codebase conventions, past debugging sessions, decisions made — without re-explaining every time

- **Writing partner**: Claude remembers your voice, past drafts, research notes, recurring characters or concepts

- **Support agent**: Claude recalls prior tickets, user preferences, known issues — contextualizing new requests against history

- **Research assistant**: Claude accumulates findings across sessions, links related papers, tracks open questions

The context_chain tool is particularly powerful here: it combines ANN search with graph traversal, surfacing not just semantically similar memories but their connected context — decisions that led to an outcome, papers that cite each other, tickets related by component.

## Install

```bash
pip install feather-db  # includes feather-serve

```

**GitHub:** [github.com/feather-store/feather](https://github.com/feather-store/feather) · **Docs:** [getfeather.store/docs/integrations](https://getfeather.store/docs/integrations)

---

*This is the machine-readable mirror of the theory post at [getfeather.store/theory/feather-db-mcp-remote-backend-claude](https://getfeather.store/theory/feather-db-mcp-remote-backend-claude). For the full Feather DB documentation, see [getfeather.store/llms-full.txt](https://getfeather.store/llms-full.txt).*