Bridge

A Bridge turns a set of your connected tools into a single MCP endpoint that an AI agent can call. Instead of wiring each tool into the agent by hand, you build a Bridge once on a visual canvas, give the agent one URL, and the Bridge serves both the raw tools and the context-assembly pipelines you composed.

The canvas is not decoration — it is where you build chains that gather context. Wire a tool's output into the next tool's input, run steps in sequence or in parallel, and expose the whole chain under one name. An agent calls that one name and gets back fully assembled context.

Example. Your team's "skills" live across Jira, Confluence docs, Jira tasks and a Git repo. A Bridge can compose a get_repo_context pipeline that pulls from all of them and returns one answer — the agent calls a single URL instead of orchestrating four tools itself.

How it works

Connections (GitHub, Atlassian, …)
        │  federated as MCP tools
        ▼
   ┌─────────────────────────────┐
   │           Bridge            │
   │  graph of nodes + edges     │   ← you build this on the canvas
   │  + named pipelines          │
   └─────────────────────────────┘
        │  served as one endpoint
        ▼
   https://mcp.fainflow.com/mcp/<bridgeId>
        │
        ▼
      AI agent / MCP client

A Bridge exposes two things at its endpoint:

Raw tools — every tool from the connections you added, federated through so the agent can call them directly.
Pipelines — the named chains you drew on the canvas. Each pipeline takes inputs, runs its nodes (in sequence or in parallel), and returns one result.

Build a Bridge

1. Create the Bridge

Dashboard → Bridges → New bridge. Give it a Name and pick one or more MCP connections to compose (the sources whose tools you want to federate — e.g. your GitHub or Atlassian connection), then Create bridge.

2. Open the canvas

Click Canvas on the Bridge. You get a node editor with a palette on the left, the graph in the center, and an inspector on the right.

3. Add nodes

From the palette (Add node):

Add tool node — pick a connection, then a tool. Its arguments appear as input ports; its result is an output port. Tool ports are fixed by the tool's schema.
Input — the pipeline's entry point. Add output ports here; each one becomes a named argument the agent passes in.
Output — the pipeline's exit point. Add input ports; whatever you wire into them is what the agent receives back.
Merge — combine several inputs into one object (fan-in).

4. Wire them up

Drag from a node's output port (right side) to another node's input port (left side). A connection means "feed this value into that argument."

A wire that would create a cycle is rejected — context flows forward only. Press Delete / Backspace to remove a selected node or wire.

5. Name a pipeline

Open Pipelines in the toolbar. Give the chain a name, pick its input node and output node, and add it. That name is what the agent will call.

6. Save

Press Save. The graph is persisted on the Bridge. Positions, ports and pipelines are all kept exactly as drawn.

Connect an agent

Point any MCP client at your Bridge endpoint:

https://mcp.fainflow.com/mcp/<bridgeId>

The client will see the raw federated tools and your named pipelines. It can call a pipeline by name with the arguments you defined on the Input node, and get the assembled result back.

The endpoint is OAuth-protected: the client authenticates once with your Fainflow login and the Bridge resolves to your account — it only ever sees the connections and pipelines you own.

Auditing

Every tool and pipeline call through the endpoint is recorded in your audit log — who called it, which tool, on which Bridge, whether it was a change, and the outcome. Argument values are redacted to identifiers (repo, path, query, …); free-text payloads are never stored. Review it under Audit Logs in the dashboard.

Sequential vs parallel

You don't choose this with a switch — the graph decides. Nodes that depend on each other run in order; nodes that don't are run in parallel. If two tools both feed a Merge node and neither depends on the other, the Bridge calls them at the same time and waits for both.