Connect Your Agent — Navige Setup

Step 1 — What are you building with?

Claude / MCP

Anthropic

LangChain

Python

CrewAI

Python

Custom Python

Any framework

Node.js

Any framework

Cursor

AI Code Editor

Direct REST API

Any language

Salesforce

Agentforce discovery

AWS Bedrock

Agents & AgentCore

n8n

Workflow automation

Select your environment above

We'll show you the exact steps for your stack.

Claude Desktop / Anthropic MCP

Navige is a native MCP server. Every tool call Claude makes passes through Navige automatically — no code changes needed.

⏱ ~2 min

Get your MCP URL

Your unique Navige MCP endpoint — includes your API key.

url

https://api.navige.ai/mcp?api_key=nv_your_key_here

Replace nv_your_key_here with your actual API key from app.navige.ai

Add to Claude Desktop config

Edit your claude_desktop_config.json file.

File location: ~/Library/Application Support/Claude/claude_desktop_config.json

json

{
  "mcpServers": {
    "navige": {
      "url": "https://api.navige.ai/mcp?api_key=nv_your_key_here"
    }
  }
}

Restart Claude Desktop after saving the config file for the MCP server to connect.

For Claude API / Cline

Add the MCP server URL to your client's MCP configuration. For Cursor, see the dedicated Cursor tab.

python — via SDK

from navige import Navige

# Get your MCP URL programmatically
url = Navige.mcp_url("nv_your_key_here")
# → "https://api.navige.ai/mcp?api_key=nv_your_key_here"

LangChain

Load Navige as an MCP tool server. Every tool call your agent makes is intercepted before it executes.

⏱ ~5 min

Install the MCP adapter

LangChain's official MCP client package.

bash

pip install langchain-mcp-adapters

Load Navige's tools

Connect once — every tool call your agent makes through them is governed.

python

from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "navige": {
        "url": "https://api.navige.ai/mcp?api_key=nv_your_key_here",
        "transport": "sse",
    }
})
tools = await client.get_tools()

# Pass to your agent as normal
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

Check the current API: langchain-mcp-adapters moves quickly — confirm the exact client method names against its own docs before shipping.

CrewAI

Load Navige as an MCP tool server for your crew. Every tool call is intercepted before it executes.

⏱ ~5 min

Install

crewai-tools includes CrewAI's official MCP adapter.

bash

pip install crewai-tools

Load Navige's tools into your crew

MCPServerAdapter connects once and hands your agent a governed tool list.

python

from crewai_tools import MCPServerAdapter

server_params = {
    "url": "https://api.navige.ai/mcp?api_key=nv_your_key_here",
    "transport": "sse",
}

with MCPServerAdapter(server_params) as tools:
    agent = Agent(role="...", goal="...", tools=tools)

Check the current API: confirm the exact MCPServerAdapter arguments against crewai-tools' own docs before shipping.

Custom Python Agent

Works with any Python agent — AutoGen, Haystack, custom-built, or any framework not listed above — using the official MCP client.

⏱ ~5 min

Install

The official Model Context Protocol Python SDK.

bash

pip install mcp

Connect and call a tool

Open a session, list what's available, call it — Navige evaluates the call before it runs.

python

from mcp import ClientSession
from mcp.client.sse import sse_client

async with sse_client("https://api.navige.ai/mcp?api_key=nv_your_key_here") as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()

        tools = await session.list_tools()

        result = await session.call_tool("send_email", {
            "to": "user@example.com",
            "subject": "...",
            "body": "...",
        })

Check the current API: confirm the exact client method names against the mcp package's own docs before shipping.

Node.js / TypeScript

Works with any Node.js agent — Express, Next.js, Vercel functions, or standalone scripts — using the official MCP SDK.

⏱ ~5 min

Install

The official Model Context Protocol TypeScript SDK.

bash

npm install @modelcontextprotocol/sdk

Connect and call a tool

Open a connection, list what's available, call it — Navige evaluates the call before it runs.

javascript

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';

const client = new Client({ name: 'my-agent', version: '1.0.0' });
const transport = new SSEClientTransport(
  new URL('https://api.navige.ai/mcp?api_key=nv_your_key_here')
);
await client.connect(transport);

const { tools } = await client.listTools();

const result = await client.callTool({
  name: 'send_email',
  arguments: { to: 'ceo@bank.com', subject: 'Contract', body: '...' },
});

Cursor (AI Code Editor)

Connect Navige as a native MCP server so every tool call Cursor's agent makes — web searches, code execution, custom tools — is logged, governed, and auditable.

⏱ ~3 min

Add Navige to Cursor's MCP config

Create or edit ~/.cursor/mcp.json for global setup, or .cursor/mcp.json in your project root for project-only scope.

json — ~/.cursor/mcp.json

{
  "mcpServers": {
    "navige": {
      "url": "https://api.navige.ai/mcp?api_key=nv_your_key_here"
    }
  }
}

Prefer the UI? Open Cursor Settings → Features → MCP → Add new MCP server, choose SSE type, and paste the URL above with your key.

Restart Cursor

MCP servers are loaded on startup — a restart picks up the new config.

Restart Cursor (or Cmd+Shift+P → Reload Window) after saving mcp.json. Navige will appear as a connected MCP server in the status bar.

What's governed — and what isn't

MCP tool calls: full interception, governance, and audit trail. Native editor actions run outside MCP and aren't covered.

✓ Governed via MCP

Web searches
Custom tools
Code execution
File read/write (MCP tools)
API calls (MCP tools)

⚠ Not interceptable

Native file edits
Built-in terminal
Cursor's own model calls
(these run inside Cursor, outside MCP)

Cursor's own model calls and native editor actions run inside Cursor itself, outside any MCP server — Navige has no visibility into them.

Direct REST API — any language

No MCP client, no SDK required. Any system that can make an authenticated HTTPS request — an internal script, a workflow engine, a no-code platform's webhook step — gets a real, governed decision from the same pipeline every other integration uses.

⏱ ~5 min

Get a virtual key

From your dashboard's Agents page, click "+ New agent" — the key is shown once, starts with nv_.

Call /enforce before your action runs

Send the tool name and a name for your system. Navige logs it, checks your policies, and returns a decision — it never performs the action itself.

bash

curl -X POST https://api.navige.ai/enforce \
  -H "Authorization: Bearer nv_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"tool": "send_invoice", "system": "billing-script"}'

Act on the decision

Only perform the real action when the decision is allow or approved. A deny/rejected/expired decision means don't.

python

import requests

resp = requests.post(
    "https://api.navige.ai/enforce",
    headers={"Authorization": "Bearer nv_your_key_here"},
    json={"tool": "send_invoice", "system": "billing-script"},
)
decision = resp.json()["decision"]

if decision in ("allow", "approved"):
    send_invoice(...)  # perform the real action only now

javascript

const res = await fetch("https://api.navige.ai/enforce", {
  method: "POST",
  headers: {
    Authorization: "Bearer nv_your_key_here",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ tool: "send_invoice", system: "billing-script" }),
});
const { decision } = await res.json();

if (decision === "allow" || decision === "approved") {
  await sendInvoice(...); // perform the real action only now
}

The first call for a new system/tool pair registers it automatically — no setup step needed. It shows up in your Registry immediately, individually kill-switchable from then on.

Approvals can take time. If a policy requires human approval, this call waits for a decision (up to 5 minutes) before responding. If your caller has a shorter timeout — a webhook handler, an Apex callout — add "wait": false to the request body: you'll get {"decision": "pending", "approvalId": "..."} back immediately, then poll GET /enforce/status/<approvalId> (same auth header) until the decision resolves.

Salesforce — Agentforce discovery

Fully self-serve, entirely from your dashboard — no CLI, no code deployed into Salesforce for this part. Discovers every Agentforce and Einstein Bot agent in your org and records what CRM data each one can reach.

⏱ ~10 min

Salesforce Connected Apps are scoped to the org that creates them — there's no single "click to connect" button that works across every customer's org. You'll create one small app inside your own Salesforce org first (steps 1–2 below), then connect it from Navige.

Create a Connected App in Salesforce

In Salesforce Setup, go to App Manager → New External Client App (or "New Connected App" on older orgs — either works). Enable OAuth Settings.

Set the Callback URL to exactly:
https://app.navige.ai/api/platforms/salesforce/callback

Add OAuth scopes api and refresh_token, offline_access. Leave "Require Proof Key for Code Exchange (PKCE)" on — External Client Apps enforce this by default, and Navige's OAuth flow requires it.

Copy your Consumer Key and Secret

Save the app, wait a few minutes for Salesforce to finish provisioning it, then open Manage Consumer Details on the app you just created and copy both values.

Connect from your Navige dashboard

Go to Settings → Salesforce (Agentforce) in Navige. Enter your instance URL (your org's My Domain, e.g. https://yourorg.my.salesforce.com), the Consumer Key, and the Consumer Secret from step 2, then click Connect Salesforce.

You'll be redirected to Salesforce's own login and consent screen — this is real Salesforce OAuth, not a Navige-hosted form. Log in and approve, and you're redirected straight back to Navige, connected.

AWS — Bedrock Agents & AgentCore

Covers both AWS agent products. Discovery is self-serve from your dashboard using a cross-account IAM role — the same pattern Datadog, PagerDuty, and Snyk use. Nothing long-lived ever leaves your AWS account.

⏱ ~10 min

AWS has no OAuth consent screen for third-party access, so this works differently from Salesforce: you generate setup instructions in Navige first, create an IAM role from them in your own AWS account, then paste back the role's ARN.

Generate setup instructions

Go to Settings → AWS (Bedrock Agents) in Navige and click Generate setup instructions. You'll get a stable per-org External ID plus ready-to-paste trust-policy and permission-policy JSON.

Create the IAM role in your AWS account

In IAM → Roles → Create role → Custom trust policy, paste the trust policy Navige gave you. Attach the permission policy as a new customer-managed policy. Name the role anything you like.

The permission policy is read-only across both AWS agent products — bedrock:ListAgents/GetAgent for Bedrock Agents Classic, bedrock-agentcore:ListAgentRuntimes/GetAgentRuntime/ListHarnesses/GetHarness for AgentCore. Navige never gets write access to anything in your account.

Connect from your Navige dashboard

Paste the role's ARN and your region back into the same Settings panel, then click Verify & Connect. Navige assumes the role for real before saving anything — a mismatched trust policy fails immediately with a clear error.

For real-time enforcement

Optional, separate from discovery. Bedrock Agents Classic: deploy a small reusable Lambda module that gates an Action Group before it executes. AgentCore: no code at all — point a Gateway Target at Navige's existing MCP endpoint with an API-key credential provider, and every tool call routed through that gateway is governed.

Full instructions and the Lambda package source are in the aws/ directory of the Navige repository.

n8n — governance in a workflow

A published community node. Drop a "Check Governance Decision" step into any n8n workflow, right before the step you want governed — no custom HTTP request node required.

⏱ ~5 min

Install the node

In your n8n instance: Settings → Community Nodes → Install, then enter the package name below.

npm

n8n-nodes-navige

Get a virtual key

From your dashboard's Agents page, click "+ New agent" — the key is shown once, starts with nv_.

Add the Navige node to your workflow

Drop it in right before the step you want governed. Create the "Navige API" credential with your key, set a Tool Name (e.g. send_invoice) and System (your workflow's name), and leave "Stop Workflow If Not Allowed" on.

Need to pause for a human approval on a step your workflow can't afford to block on? Turn off Wait for Decision — you'll get a pending result immediately, then use the Check Approval Status operation later in the workflow to see how it was resolved.

Connect your AI agent
to Navige

Select your environment above

Test it

Run your agent

Kick off your crew

Run your agent

Run your agent

Test it

Test it

Test it

Test it

Test it

Connect your AI agentto Navige

Select your environment above

Test it

Run your agent

Kick off your crew

Run your agent

Run your agent

Test it

Test it

Test it

Test it

Test it

Connect your AI agent
to Navige