# Bridge MCP

MCP server for [Bridge](https://bridge.strine.com.br) — save the reasoning from
a planning conversation and hand it to a coding agent, without leaving the
chat.

## The problem

You plan a project in one AI conversation — Claude.ai, ChatGPT, wherever —
working through decisions, trade-offs, and alternatives you discarded and
why. Then you open a coding agent (Claude Code, Cursor, Codex) to actually
build it, and all of that reasoning is gone. You re-explain from scratch, or
the agent only gets a condensed PRD — the conclusion, not the *why*.

Bridge exists to carry that reasoning across, unedited. This MCP server is
the "without leaving the chat" half of it: instead of copying the
conversation into a website, you just ask the model you're already talking
to to save it.

## What it does

Two tools, callable from any [MCP](https://modelcontextprotocol.io)-compatible
client:

| Tool | Input | Output |
|---|---|---|
| `save_context` | `conteudo` (text, required), `titulo` (optional) | a short link — `bridge.strine.com.br/c/<id>` |
| `get_context` | `id` | the saved content, as plain text |

**This server runs no AI of its own.** It only stores and returns text. The
model on your side of the conversation — Claude.ai, or the coding agent
reading the link — is what does the actual summarizing and interpreting.
That keeps the AI cost where it already lives (in the agent you're paying
for), not duplicated on this server.

## Add it as a connector

In Claude.ai: **Settings → Connectors → Add custom connector**

```
Name: Bridge
URL:  https://bridge-mcp-three.vercel.app/mcp
```

No authentication, no API key — it's a stateless server, nothing to configure.

## How the two sides fit together

1. Finish a planning conversation. Say something like *"save this context to
   Bridge."* The model calls `save_context` and a link comes back in the
   same message.
2. Hand that link to your coding agent — paste it directly, or (if that tool
   also has this MCP server configured) let it call `get_context` itself.
3. The agent reads the decisions, the reasons, and what was ruled out —
   instead of just the final ask.

## Architecture

- **Stateless [Streamable HTTP](https://modelcontextprotocol.io/specification)
  transport** — no session id, no long-lived connection between requests.
  That's what lets this run as an ordinary Vercel serverless function
  instead of needing an always-on process.
- **Same Supabase table** the [Bridge website](https://bridge.strine.com.br)
  already reads and writes — this server is a second door into the same
  data, not a parallel system.
- TypeScript, [`@modelcontextprotocol/sdk`](https://github.com/modelcontextprotocol/typescript-sdk),
  deployed via `@vercel/node`.

## Local development

```bash
npm install
npm run dev          # stdio transport, for local MCP clients
npm run inspector     # opens the MCP Inspector web UI against this server
```

Needs a `.env` with `SUPABASE_URL` and `SUPABASE_SECRET_KEY` — same
credentials the [Bridge website](https://bridge.strine.com.br) uses.

## Related

- [bridge.strine.com.br](https://bridge.strine.com.br) — the website: paste
  text manually, get a link. No MCP client required.
- [Model Context Protocol](https://modelcontextprotocol.io) — the open
  standard this server implements.

---

This is v2 of Bridge, adding an MCP connector on top of a v1 that already
validated the core idea (link + instruction, no MCP required) with real
usage across Claude Code, Codex, and Cursor.