Reduce Token Use and Response Time in Your LangChain Agent With Airbyte

Name: Airbyte — Reduce Token Use and Response Time in Your LangChain Agent With Airbyte
Author: Airbyte

Reduce token use and speed up LangChain agents with Airbyte’s context layer, unified data access, and agent-ready connectors.

Intermediate

Richelle

updatedJuly 9, 2026

connectors used

Airbyte

If you've ever sent an agent to synthesize data from multiple MCP servers, you know the routine. It pulls data. It pages through results. It guesses at filter parameters, gets a 404, backs off a rate limit, and tries again. By the time it finds the information from one source, it's burned a dozen tool calls and a small fortune in tokens all just to figure out where the data lives. It hasn't actually done anything yet.

When an agent calls an MCP server, it almost never knows where the data is up front. Before it can do anything, it has to go discovery shopping: listing resources, paging through results, iteratively narrowing with filters. When the dataset gets large, the search becomes time consuming.

Airbyte's Context Store offers a simple solution. The Context Store allows the agent to read from a managed index first, only hitting the live API when it genuinely needs fresh data. This post walks through how to wire up a Slack connector to a LangChain agent as a callable tool.

A quick note on what you'll need to follow along:

An account at app.airbyte.ai
Python 3.10 or later
A LangChain project where you can register tools
Credentials for your sources (I'm using Slack)
(Optional) A copy of the sample app, which can be found in the [quickstarts] GitHub repo

What is the Context Store?

The Context Store saves your agent time by storing your data for easy filtering and sorting. It periodically replicates a relevant slice of your data into a managed, searchable context layer. Instead of scanning the full API on every request, the agent asks the Context Store first. If the Context Store can answer, it can skip the live API call entirely. If it can't, the agent falls back to a live call for a fresh state. This extra step saves your agent from slow and failure-prone round trips.

And the savings aren't hand-wavy. Our initial benchmarking shows that agents using the Context Store make 40% fewer tool calls and burn up to 80% fewer tokens.

By the end of this post, you'll have the same setup (minus the credentials; you'll need to populate your own .env file).

[!IMPORTANT] The Context Store is the right tool when your agent searches, filters, or discovers records across a large dataset, and when it’s okay to rely on data from up to a few minutes ago. The Context Store refreshes on a schedule, meaning that it offers recent, not real-time, data. Thankfully, if you need to know what occurred within the last five minutes, your agent can automatically use Context Store for initial discovery and the live connector for the freshest data.

Step 1: Set up your connectors in Airbyte

Before any of the agent code, you need data. In the Airbyte UI, create a connector for each source you want the agent to reach and complete the auth flow for each one. I've connected Slack.

It may take some time for the Context Store to load the initial index. The UI will tell you everything’s loaded by marking the source’s status as 'Ready'.

For more information on how to connect your sources to Airbyte Agents, see Agent connectors in Airbyte documentation.

Step 2: Save credentials and install packages

In the shell, create your application using the following commands:

uv python init <project-name>

cd <project-name>

uv add airbyte-agent-sdk langchain langchain-openai python-dotenv

Drop your Airbyte and agent credentials into a .env file in your project root and load them at runtime:

# .env
AIRBYTE_API_KEY=your_api_key
AIRBYTE_WORKSPACE_ID=your_workspace_id

OPENAI_API_KEY=your_agent_api_key

If you haven't already, add .env to your .gitignore so it never makes it into a commit. Future you will be grateful.

Step 3: Define a tool with the Airbyte SDK

Now let’s tell the agent about your Context Store. The Airbyte Python SDK gives you a tool_utils decorator to register a LangChain tool as an Airbyte connection. This decorator allows the SDK to handle both the Context Store connection and the live connector fallback for you.

Here's a tool that searches Slack. The decorator exposes the function to the agent, and the body queries the Context Store first:

import json
from dotenv import load_dotenv
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.slack import SlackConnector
from langchain.tools import tool

# Pull Airbyte and OpenAI credentials from the .env file
load_dotenv()

# Use Airbyte credentials to access Slack credentials (authenticated via OAuth) 
slack = connect("slack")

@tool
@SlackConnector.tool_utils
async def slack_execute(entity: str, action: str, params: dict | None = None) -> str:
    result = await slack.execute(entity, action, params or {})
    return json.dumps(result, default=str)

I've also imported tool from LangChain, which tells LangChain to treat my Slack connection as an agent tool.

Notice how I don’t include a docstring for this connector. Connectors automatically ship with the skills your agent needs. You should only include a docstring for the Airbyte Agents tool if you need to restrict what data the agent can access or how it’s allowed to use that data.

Order matters with tool decorators. I’ve placed @SlackConnector.tool_utils below `@tool` because the tool_utils connector includes a default description docstring. Airbyte recommends that you use the default description, so make sure you include the tool decorators in the above order. You can find more about tool creation in the [Execute operations] documentation.

Step 4: Hand the tool to your LangChain agent

It's time to pass the decorated tool to your agent alongside all its other tools. From here on, slack_execute is part of the agent's reasoning toolkit:

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

agent = create_agent(
    llm,
    [slack_execute],
    system_prompt=(
        "You are a helpful assistant that can access Slack data through the "
        "slack_execute tool. Be concise and accurate. "
        "To find or filter messages (by channel, user, or date), use "
        "entity='messages', action='list' with the target channel and an "
        "'oldest'/'latest' Unix timestamp range. "
        "To resolve a channel name to an ID, use entity='channels', "
        "action='list' first."
    ),
)

You'll notice that the system prompt for this agent adds specific information about how to filter. This helps the agent avoid making calls to inappropriate APIs if the Context Store can't answer the query.

Step 5: Query the agent

Add the following code to your main Python file:

async def _demo():
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "List the messages I sent in #general in May 2026."}]}
    )
    print(result["messages"][-1].content)

if __name__ == "__main__":
    import asyncio

    asyncio.run(_demo())

The agent should respond to this command with all the messages you sent in #general in May of 2026.

To confirm, run the file. For example, you can run the following command in the terminal:

uv run main.py

When this runs, the agent calls slack_execute, which checks the Context Store for relevant data. If the store has an answer, the agent uses it without wasting time on an API call. If it doesn't, the tool quietly falls back to the live Slack API.

Where that leaves you

You've now got a LangChain agent that reaches for the Airbyte Context Store before it ever touches a live API. The result: fewer tool calls, fewer tokens, fewer API call errors.

The more tools you add, the more token savings you unlock. Some examples of using Airbyte Agents to retrieve data more efficiently include:

Connect a support agent to internal documentation in Notion, PRs in GitHub, and previous customer interactions in SalesForce
Build an agent that collects customer requests from Zendesk to create GitHub issues with context about user demand. That pattern is a customer request to feature tracker, turning support signal into prioritized product work.
Collect analytics across your TikTok, Pinterest, Snapchat, Amazon, and Facebook marketing accounts to understand customer sentiment and behavior around your campaigns.

If you want to dig into the numbers or the internals, the Airbyte Agents benchmark post has the full breakdown, and the Context Store documentation covers the concepts in depth. Now go point it at your own sources to see how many tokens you can save.

Build agents on live data

The Free plan includes 1,000 Agent Operations and 50+ agent connectors.

Try it free