LangChain

import os
import scalekit.client
from dotenv import load_dotenv

load_dotenv()

scalekit_client = 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

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
from langchain_openai import ChatOpenAI
2
from langchain_core.messages import HumanMessage, ToolMessage
3

4
tools = actions.langchain.get_tools(
5
    identifier="user_123",
6
    connection_names=["gmail"],
7
    page_size=100,  # avoid missing tools when a connector has more than the default page
8
)
9
tool_map = {t.name: t for t in tools}
10

11
llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)
12
messages = [HumanMessage("Fetch my last 5 unread emails and summarize them")]
13

14
while True:
15
    response = llm.invoke(messages)
16
    messages.append(response)
17
    if not response.tool_calls:
18
        print(response.content)
19
        break
20
    for tc in response.tool_calls:
21
        result = tool_map[tc["name"]].invoke(tc["args"])
22
        messages.append(ToolMessage(content=str(result), tool_call_id=tc["id"]))

1
import asyncio
2
import os
3
from datetime import timedelta
4
from langchain_mcp_adapters.client import MultiServerMCPClient
5
from langchain_openai import ChatOpenAI
6
from langchain_core.messages import HumanMessage, ToolMessage
7

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

12
# Mint a fresh session token for this user before each agent run
13
mcp_token = actions.mcp.create_session_token(
14
    mcp_config_id=config_id,
15
    identifier="user_123",
16
    expiry=timedelta(hours=1),
17
).token
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
    tools = await client.get_tools()
30
    tool_map = {t.name: t for t in tools}
31
    llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)
32
    messages = [HumanMessage("Fetch my last 5 unread emails and summarize them")]
33

34
    while True:
35
        response = await llm.ainvoke(messages)
36
        messages.append(response)
37
        if not response.tool_calls:
38
            print(response.content)
39
            break
40
        for tc in response.tool_calls:
41
            result = await tool_map[tc["name"]].ainvoke(tc["args"])
42
            messages.append(ToolMessage(content=str(result), tool_call_id=tc["id"]))
43

44
asyncio.run(run())