Connect User Data Example

Learn how to connect user data to your AI agent or application

Prerequisites:

1. You have already obtained an access token from your user

2. Your access token has access to the necessary scopes to make MCP server requests

Select MCP Servers

BlueNexus supports many MCP Servers. You need to select the MCP server(s) that are relevant for your application and that a user has connected.

Checking connected MCP Servers

MCP servers are only available to your application if the user account has connected the underlying service (Google, Fitbit, etc.) and your application has permission to access that data and MCP servers.

You can check the available MCP servers for a given user by making a request to GET https://api.bluenexus.ai/api/v1/mcps:

curl -X GET "https://api.bluenexus.ai/api/v1/mcps" \
  -H "Authorization: Bearer USER_ACCESS_TOKEN"

Selecting a MCP Server

Extract the url from the response to identify the MCP endpoint(s) for connecting to your LLM.

Example response:

{
    "data": [
        {
            "slug": "notion",
            "label": "Notion",
            "url": "https://api.bluenexus.ai/api/v1/mcps/notion",
            "isActive": true // Indicates if this user is connected to the service (Notion in this case)
        }
    ]
}

In this example you can use the url https://api.bluenexus.ai/api/v1/mcps/notion.

The isActive field indicates whether the user is connected to the underlying service (Notion in this case) and given your application the permissions to use it. For MCP servers where isActive is false, your application can respectfully encourage the user to connect and allow the service first. Trying to use an MCP server that is not active will result in a 403 Forbidden error.

Setup your LLM

Create an AI agent using the library of your choice. You can utilize a third party LLM (ie: Anthropic or OpenAI) or you can use the built-in LLMs provided by BlueNexus which include confidential LLM's for enhanced privacy.

Example 1: Using Anthropic LLM

Here's an example using LangChain with Anthropic:

// Import required dependencies
import { createAgent } from "langchain";
import { ChatAnthropic } from "@langchain/anthropic";

// Initialize the Anthropic chat model
const llm = new ChatAnthropic({
  model: "claude-sonnet-4-5-20250929",
  apiKey: process.env.ANTHROPIC_API_KEY, // Set your API key
  temperature: 0.7,
});

// Create agent using the createAgent from langchain package
const agent = createAgent({
  model: llm, // Pass the pre-configured ChatAnthropic instance
  tools: [], // Tools will be added after connecting MCP servers
  systemPrompt: `You are a helpful and wellness AI assistant with secure access to the user's data through MCP servers.
    Always prioritize user privacy and security. Only access data that is necessary to fulfill the user's request.`,
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "Hello, who are you?" }],
});

const response = result.messages[result.messages.length - 1];
console.log("Assistant:", response.content);

Example 2: Using BlueNexus LLM

Here's an example using LangChain with BlueNexus built-in LLM for enhanced privacy:

// Import required dependencies
import { ChatOpenAI } from "@langchain/openai";
import { createAgent } from "langchain";

// Initialize the BlueNexus LLM
// This uses BlueNexus's confidential computing infrastructure
const llm = new ChatOpenAI({
  model: "redpill:phala/gpt-oss-120b", // BlueNexus supports multiple confidential models
  apiKey: "not-used", // Placeholder - actual auth is via Bearer token
  configuration: {
    baseURL: "https://api.bluenexus.ai/api/v1", // BlueNexus LLM endpoint
    defaultHeaders: {
      Authorization: `Bearer ${USER_ACCESS_TOKEN}`, // Your user's access token
    },
  },
  temperature: 0.7,
});

// Create agent using the new createAgent from langchain package
const agent = createAgent({
  model: llm, // Pass the pre-configured ChatOpenAI instance
  tools: [], // Tools will be added after connecting MCP servers
  systemPrompt: `You are a helpful and wellness AI assistant with secure access to the user's data through MCP servers.
Always prioritize user privacy and security. Only access data that is necessary to fulfill the user's request.`,
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "Hello, who are you?" }],
});

const response = result.messages[result.messages.length - 1];
console.log("Assistant:", response.content);

Connect MCP Servers

Connect your LLM to one or more MCP servers.

Here's an example using LangChain:

// Import MCP client dependencies
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { loadMcpTools } from "@langchain/mcp-adapters";

// Function to connect to an MCP server and retrieve its tools
async function connectToMCPServer(serverUrl: string, accessToken: string) {
  // Initialize MCP client
  const mcpClient = new Client({
    name: "example-app-mcp-client",
    version: "1.0.0",
  });

  // Create transport with authentication
  const transport = new StreamableHTTPClientTransport(
    new URL(serverUrl),
    {
      requestInit: {
        headers: {
          Authorization: `Bearer ${accessToken}`,
        },
      },
    }
  );

  // Establish connection to the MCP server
  await mcpClient.connect(transport);

  // Load tools in LangChain-compatible format
  const tools = await loadMcpTools("mcp-server", mcpClient);

  return { client: mcpClient, tools };
}


// Connect to multiple MCP servers
// URLs obtained from the /mcps endpoint
const notionConnection = await connectToMCPServer(
  `https://api.bluenexus.ai/api/v1/mcps/notion`,
  USER_ACCESS_TOKEN // Your user's access token
);

const googleWorkspaceConnection = await connectToMCPServer(
  `https://api.bluenexus.ai/api/v1/mcps/google-workspace`,
  USER_ACCESS_TOKEN // Your user's access token
);

// Log available tools from each server
console.log("\nNotion tools:", notionConnection.tools.map((t) => t.name));
console.log("Google Workspace tools:", googleWorkspaceConnection.tools.map((t) => t.name));

// Combine tools from all MCP servers
const mcpTools = [
  ...notionConnection.tools,
  ...googleWorkspaceConnection.tools,
];

console.log(`\nTotal tools available: ${mcpTools.length}`);

// Clean up connections
await notionConnection.client.close();
await googleWorkspaceConnection.client.close();

Automatically Connect All Active MCP Servers

Instead of manually connecting to each MCP server, you can automatically discover and connect to all active MCP servers that you have activated. This requires two steps:

1. Retrieve the URLs of all active MCP servers (where isActive = true)

2. Iteratively connect to each server to fetch their tools

Here's an example:

// Define BlueNexusMcpServer type
type BlueNexusMcpServer = {
  slug: string;
  label: string;
  url: string;
  isActive: boolean;
};

// Function to fetch all active MCP servers
async function getActiveMCPServers(accessToken: string) {
  const response = await fetch("https://api.bluenexus.ai/api/v1/mcps", {
    headers: {
      Authorization: `Bearer ${accessToken}`,
    },
  });

  const data = await response.json();

  // Filter for active servers only
  return data.data.filter((server: BlueNexusMcpServer) => server.isActive);
}

// Get all active MCP servers
const activeServers = await getActiveMCPServers(USER_ACCESS_TOKEN);  // Your user's access token

console.log(`Found ${activeServers.length} active MCP servers`);

// Connect to all active MCP servers dynamically
const connections = await Promise.all(
  activeServers.map(async (server: BlueNexusMcpServer) => {
    console.log(`Connecting to ${server.label}...`);
    const connection = await connectToMCPServer(server.url, USER_ACCESS_TOKEN);  // Your user's access token
    return {
      id: server.slug,
      label: server.label,
      connection,
    };
  })
);

// Log available tools from each server
connections.forEach((conn) => {
  console.log(`${conn.label} tools:`, conn.connection.tools.map((t) => t.name));
});

// Combine tools from all active MCP servers
const allMCPTools = connections.flatMap((conn) => conn.connection.tools);

console.log(`Total tools available: ${allMCPTools.length}`);

// Store connections for later cleanup
const mcpConnections = connections.map((conn) => conn.connection);

This approach allows your application to automatically adapt to whatever MCP servers you have connected, without hardcoding specific server names.

Make LLM Request

Now, your application can submit a LLM prompt that will utilize the connected MCP servers.

Here's an example using LangChain:

// Update the agent with MCP tools
// Recreate the agent with the tools from the MCP server
const agentWithTools = createAgent({
  model: llm,
  tools: mcpTools, // Include MCP tools from the connected server
  systemPrompt: `You are a helpful and wellness AI assistant with secure access to the user's data through MCP servers.
  Always prioritize user privacy and security. Only access data that is necessary to fulfill the user's request.`,
});

// Invoke the agent with a user prompt
// The agent will automatically use MCP tools when needed
// With multiple MCP servers connected, the agent can access both Notion and Google Workspace
const response = await agentWithTools.invoke({
  messages: [
    {
      role: "user",
      content: "Can you find my recent Notion pages about project planning and check if I have any related emails in Gmail?",
    },
  ],
});

// Extract and display the response
// The agent's response will include data retrieved via MCP tools
console.log("Agent response:", response.messages[response.messages.length - 1].content);

// Clean up: Close all MCP connections when done
await notionConnection.client.close();
await googleWorkspaceConnection.client.close();

Note: If you used the automatic connection approach from the previous section, replace mcpTools with allMCPTools and clean up connections like this:

// Clean up: Close all MCP connections when done (automatic approach)
await Promise.all(mcpConnections.map((conn) => conn.client.close()));