LangChain

Build a LangChain agent that reads a user’s Gmail inbox. Scalekit handles OAuth, token storage, and returns tools in native LangChain format. Your agent code needs no Scalekit-specific logic beyond initialization.

Full code on GitHub

Install

pip install scalekit-sdk-python langchain-openai

Initialize

import os
import scalekit.client

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

Connect the user to Gmail

response = actions.get_or_create_connected_account(
    connection_name="gmail",
    identifier="user_123",
)
if response.connected_account.status != "ACTIVE":
    link = actions.get_authorization_link(connection_name="gmail", identifier="user_123")
    print("Authorize Gmail:", link.link)
    input("Press Enter after authorizing...")

See Authorize a user for production auth handling.

Build and run the agent

actions.langchain.get_tools() returns native StructuredTool objects. Bind them to your LLM and run the tool-calling loop:

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, ToolMessage

tools = actions.langchain.get_tools(
    identifier="user_123",
    connection_names=["gmail"],
)
tool_map = {t.name: t for t in tools}

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

while True:
    response = llm.invoke(messages)
    messages.append(response)
    if not response.tool_calls:
        print(response.content)
        break
    for tc in response.tool_calls:
        result = tool_map[tc["name"]].invoke(tc["args"])
        messages.append(ToolMessage(content=str(result), tool_call_id=tc["id"]))

Multiple Gmail accounts

If a user has multiple Gmail connections, pass the specific connection_names value from your Scalekit dashboard to scope tools to the right one.

Use MCP instead

LangChain supports MCP via langchain-mcp-adapters. Install it, then connect to a Scalekit-generated MCP URL:

pip install langchain-mcp-adapters

import asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, ToolMessage

async def run(mcp_url: str):
    async with MultiServerMCPClient(
        {"scalekit": {"transport": "streamable_http", "url": mcp_url}}
    ) as client:
        tools = client.get_tools()
        tool_map = {t.name: t for t in tools}
        llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)
        messages = [HumanMessage("Fetch my last 5 unread emails and summarize them")]

        while True:
            response = await llm.ainvoke(messages)
            messages.append(response)
            if not response.tool_calls:
                print(response.content)
                break
            for tc in response.tool_calls:
                result = await tool_map[tc["name"]].ainvoke(tc["args"])
                messages.append(ToolMessage(content=str(result), tool_call_id=tc["id"]))

asyncio.run(run(mcp_url))

See Generate user MCP URLs to get mcp_url.