LangGraph

import os
from dotenv import load_dotenv
from scalekit import ScalekitClient

load_dotenv()

scalekit_client = ScalekitClient(
    client_id=os.getenv("SCALEKIT_CLIENT_ID"),
    client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
    env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
)
actions = scalekit_client.actions

import 'dotenv/config';
import { ScalekitClient } from '@scalekit-sdk/node';

const scalekit = new ScalekitClient(
  process.env.SCALEKIT_ENVIRONMENT_URL!,
  process.env.SCALEKIT_CLIENT_ID!,
  process.env.SCALEKIT_CLIENT_SECRET!,
);

1
# Connect the user's Gmail account, and wait until it's ACTIVE before calling tools
2
connection_name = "gmail"
3
identifier = "user_123"  # your app's unique user ID
4

5
response = actions.get_or_create_connected_account(
6
    connection_name=connection_name, identifier=identifier
7
)
8
if response.connected_account.status != "ACTIVE":
9
    link = actions.get_authorization_link(
10
        connection_name=connection_name, identifier=identifier
11
    )
12
    print("Authorize Gmail:", link.link)
13
    input("Press Enter after authorizing...")
14
    # Fetch the account again to pick up the new status
15
    response = actions.get_or_create_connected_account(
16
        connection_name=connection_name, identifier=identifier
17
    )
18

19
if response.connected_account.status != "ACTIVE":
20
    raise RuntimeError(
21
        f"Gmail is {response.connected_account.status}, not ACTIVE. Authorize it and run again."
22
    )

1
import { createInterface } from 'node:readline/promises';
2
import { ConnectorStatus } from '@scalekit-sdk/node';
3

4
// Connect the user's Gmail account, and wait until it's ACTIVE before calling tools
5
const connectionName = 'gmail';
6
const identifier = 'user_123'; // your app's unique user ID
7

8
let { connectedAccount } = await scalekit.actions.getOrCreateConnectedAccount({
9
  connectionName,
10
  identifier,
11
});
12
if (connectedAccount?.status !== ConnectorStatus.ACTIVE) {
13
  const { link } = await scalekit.actions.getAuthorizationLink({ connectionName, identifier });
14
  console.log('Authorize Gmail:', link);
15
  const rl = createInterface({ input: process.stdin, output: process.stdout });
16
  await rl.question('Press Enter after authorizing...');
17
  rl.close();
18
  // Fetch the account again to pick up the new status
19
  ({ connectedAccount } = await scalekit.actions.getOrCreateConnectedAccount({
20
    connectionName,
21
    identifier,
22
  }));
23
}
24

25
if (connectedAccount?.status !== ConnectorStatus.ACTIVE) {
26
  throw new Error(`Gmail is not ACTIVE (status ${connectedAccount?.status}). Authorize it and run again.`);
27
}

1
from langchain_openai import ChatOpenAI
2
from langgraph.graph import START, MessagesState, StateGraph
3
from langgraph.prebuilt import ToolNode, tools_condition
4

5

6
def build_graph(tools):
7
    llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)
8

9
    def call_model(state: MessagesState):
10
        return {"messages": [llm.invoke(state["messages"])]}
11

12
    builder = StateGraph(MessagesState)
13
    builder.add_node("agent", call_model)
14
    builder.add_node("tools", ToolNode(tools))
15
    builder.add_edge(START, "agent")
16
    # Run the tools the model asked for, or end when it answers without tool calls
17
    builder.add_conditional_edges("agent", tools_condition)
18
    builder.add_edge("tools", "agent")
19
    return builder.compile()
20

21

22
tools = actions.langchain.get_tools(
23
    identifier=identifier,
24
    connection_names=[connection_name],
25
    page_size=100,  # up to 100 tools per page; page with page_token for more
26
)
27
graph = build_graph(tools)
28
result = graph.invoke(
29
    {"messages": [("user", "Fetch my last 5 unread emails and summarize them")]}
30
)
31
print(result["messages"][-1].content)

1
import { ChatOpenAI } from '@langchain/openai';
2
import { tool, type StructuredToolInterface } from '@langchain/core/tools';
3
import { MessagesAnnotation, START, StateGraph } from '@langchain/langgraph';
4
import { ToolNode, toolsCondition } from '@langchain/langgraph/prebuilt';
5

6
function buildGraph(tools: StructuredToolInterface[]) {
7
  const llm = new ChatOpenAI({ model: 'gpt-4o' }).bindTools(tools);
8
  return new StateGraph(MessagesAnnotation)
9
    .addNode('agent', async (state) => ({ messages: [await llm.invoke(state.messages)] }))
10
    .addNode('tools', new ToolNode(tools))
11
    .addEdge(START, 'agent')
12
    // Run the tools the model asked for, or end when it answers without tool calls
13
    .addConditionalEdges('agent', toolsCondition)
14
    .addEdge('tools', 'agent')
15
    .compile();
16
}
17

18
const { tools: scopedTools } = await scalekit.tools.listScopedTools(identifier, {
19
  filter: { connectionNames: [connectionName] },
20
  pageSize: 100, // up to 100 tools per page; page with nextPageToken for more
21
});
22
// Tool definitions are typed as generic JSON, so read each field explicitly
23
const definitions = scopedTools.flatMap((t) => (t.tool?.definition ? [t.tool.definition] : []));
24
const tools = definitions.map((definition) =>
25
  tool(
26
    async (input) => {
27
      const result = await scalekit.actions.executeTool({
28
        toolName: String(definition.name),
29
        identifier,
30
        connector: connectionName,
31
        toolInput: input as Record<string, unknown>,
32
      });
33
      return JSON.stringify(result.data);
34
    },
35
    {
36
      name: String(definition.name),
37
      description: String(definition.description ?? ''),
38
      schema: definition.input_schema as Record<string, unknown>,
39
    },
40
  ),
41
);
42

43
const graph = buildGraph(tools);
44
const result = await graph.invoke({
45
  messages: [{ role: 'user', content: 'Fetch my last 5 unread emails and summarize them' }],
46
});
47
console.log(result.messages.at(-1)?.content);

1
import asyncio
2
import os
3
from datetime import timedelta
4

5
from langchain_mcp_adapters.client import MultiServerMCPClient
6

7
# Returned by create_config when you created the Virtual MCP server
8
config_id = os.environ["SCALEKIT_MCP_CONFIG_ID"]
9
mcp_url = os.environ["SCALEKIT_MCP_SERVER_URL"]
10

11
# Mint a fresh session token for this user before each agent run
12
mcp_token = actions.mcp.create_session_token(
13
    mcp_config_id=config_id,
14
    identifier=identifier,
15
    expiry=timedelta(hours=1),
16
).token
17

18

19
async def run():
20
    client = MultiServerMCPClient(
21
        {
22
            "scalekit": {
23
                "transport": "streamable_http",
24
                "url": mcp_url,
25
                "headers": {"Authorization": f"Bearer {mcp_token}"},
26
            }
27
        }
28
    )
29
    graph = build_graph(await client.get_tools())
30
    result = await graph.ainvoke(
31
        {"messages": [("user", "Fetch my last 5 unread emails and summarize them")]}
32
    )
33
    print(result["messages"][-1].content)
34

35

36
asyncio.run(run())

1
import { MultiServerMCPClient } from '@langchain/mcp-adapters';
2

3
// Returned by createConfig when you created the Virtual MCP server
4
const configId = process.env.SCALEKIT_MCP_CONFIG_ID!;
5
const mcpUrl = process.env.SCALEKIT_MCP_SERVER_URL!;
6

7
// Mint a fresh session token for this user before each agent run
8
const session = await scalekit.actions.mcp.createSessionToken({
9
  mcpConfigId: configId,
10
  identifier,
11
  expirySeconds: 60 * 60,
12
});
13

14
const mcpClient = new MultiServerMCPClient({
15
  servers: {
16
    scalekit: {
17
      transport: 'http',
18
      url: mcpUrl,
19
      headers: { Authorization: `Bearer ${session.token}` },
20
    },
21
  },
22
});
23
try {
24
  const mcpGraph = buildGraph(await mcpClient.getTools());
25
  const mcpResult = await mcpGraph.invoke({
26
    messages: [{ role: 'user', content: 'Fetch my last 5 unread emails and summarize them' }],
27
  });
28
  console.log(mcpResult.messages.at(-1)?.content);
29
} finally {
30
  await mcpClient.close();
31
}