LangChain

Build a LangChain agent that authenticates users with Gmail and executes tools on their behalf using Scalekit Agent Auth.

This guide shows how to build a LangChain agent that authenticates users with Gmail via OAuth 2.0 and fetches their last 5 unread emails using Scalekit Agent Auth.

Full code on GitHub

Prerequisites

Before you start, make sure you have:

Scalekit API credentials — Client ID and Client Secret from app.scalekit.com
OpenAI API Key — Get from OpenAI Platform

Set up your environment

Install the Scalekit Python SDK and initialize the client. Get your credentials from Developers → Settings → API Credentials in the dashboard.

pip install scalekit-sdk-python langchain langchain-openai

import scalekit.client
import os
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_ENV_URL"),
)
actions = scalekit_client.actions

Create a connected account

Authorize a user to access their Gmail account by creating a connected account. This represents the user’s connection to their Gmail account:

1
# Create a connected account for user if it doesn't exist already
2
response = actions.get_or_create_connected_account(
3
            connection_name="gmail",
4
            identifier="user_123" # unique identifier; replace with your system's user ID
5
        )
6
connected_account = response.connected_account
7

8
print(f'Connected account created: {connected_account.id}')

Authenticate the user

For Scalekit to execute tools on behalf of the user, the user must grant authorization to access their Gmail account. Scalekit automatically handles the entire OAuth workflow, including token refresh.

1
# If the user hasn't yet authorized the gmail connection or if the user's access token is expired,
2
# generate a magic link and redirect the user to this link so that the user can complete authorization
3
if(connected_account.status != "ACTIVE"):
4
      link_response = actions.get_authorization_link(
5
          connection_name="gmail",
6
          identifier="user_123"
7
      )
8
      print(f"🔗click on the link to authorize gmail", link_response.link)
9
      input(f"⎆ Press Enter after authorizing gmail...")
10

11
# In a real app, redirect the user to this URL so that the user can complete the authentication process for their gmail account

Build a LangChain agent

Build a simple agent that fetches the last 5 unread emails from the user’s inbox and generates a summary.

1
from langchain_openai import ChatOpenAI
2
from langchain.agents import AgentExecutor, create_openai_tools_agent
3
from langchain_core.prompts import SystemMessagePromptTemplate, MessagesPlaceholder, HumanMessagePromptTemplate,PromptTemplate, ChatPromptTemplate
4

5
# use scalekit SDK to fetch all GMAIL tools in langchain format
6
tools =  actions.langchain.get_tools(
7
     identifier="user_123",
8
     providers = ["GMAIL"], # all tools for provider used by default
9
     page_size=100
10
)
11

12
prompt = ChatPromptTemplate.from_messages([
13
    SystemMessagePromptTemplate(prompt=PromptTemplate(input_variables=[], template="You are a helpful assistant. Use tools if needed")),
14
    MessagesPlaceholder(variable_name="chat_history", optional=True),
15
    HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=["input"], template="{input}")),
16
    MessagesPlaceholder(variable_name="agent_scratchpad")
17
])
18

19
llm = ChatOpenAI(model="gpt-4o")
20
agent = create_openai_tools_agent(llm, tools, prompt)
21
agent_executor = AgentExecutor(agent=agent, tools=tools,verbose=True)
22
result = agent_executor.invoke({"input":"fetch my last 5 unread emails and summarize it"}
23
)