How to Use the Retable MCP in LangChain

Q: Can a LangChain agent clean up data in Retable?

Yes, the agent can use listrecords to find stale entries and then call deleterecord to remove them. You can construct a chain that evaluates rows against specific criteria before executing the deletion.

Build multi-step LangChain reasoning pipelines that read, update, and manage your Retable spreadsheets on the fly.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers — Included with Plan

Connect Retable MCP to LangChain

Create your Vinkius account to connect Retable to LangChain — we handle the hosting, security, and runtime updates so you don't have to. No server setup required.

GDPR Included with Plan

Setup Retable with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity Vinkius runs on Gemini

Gemini

Grok

Chain spreadsheet reads and writes dynamically

This MCP Server exposes `list_records` and `create_record` to let your LangChain agents fetch existing rows and instantly write back updates based on upstream chain outputs. Your agent inspects the schema of your Retable tables, decides which columns to target, and passes the parsed data directly to the next node in your execution graph. Instead of hardcoding API calls, you let the LLM determine the data flow. For example, the agent can pull raw data with `get_record`, process it through a custom prompt, and then use `update_record` to save the structured output back to your sheet.

Trace Retable MCP Server tool calls with LangSmith

This MCP Server exposes `get_project` and `list_tables` to let LangChain track every single workspace query inside LangSmith. You track exactly when the agent calls these tools, monitoring the latency and token usage of each database operation. This setup eliminates the guesswork when debugging complex, multi-turn chains. If an agent fails to write a row, you can inspect the exact payload sent to `create_record` directly inside your tracing dashboard.

Multi-project navigation for autonomous agents

This MCP Server provides `list_projects` and `get_table` to let your LangChain agent map out your entire relational workspace before executing updates. This allows the model to discover which table contains the relevant inventory or project tracking data without manual hardcoding. By combining these navigation tools with LangChain's memory modules, the agent builds a temporary schema map. It checks connectivity with `check_retable_status` first, ensuring your pipeline doesn't break mid-execution due to expired tokens.

Setup guide

Set up Retable MCP in LangChain

Prerequisites

Python 3.10+ installed
langchain-mcp-adapters + langgraph packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install langchain-mcp-adapters langgraph langchain-openai. The MCP adapters package converts MCP tools into native LangChain BaseTool objects.
2

Connect via HTTP transport
Use MultiServerMCPClient with "transport": "http" pointing to your Vinkius endpoint. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Create a ReAct agent
Pass the discovered tools to create_react_agent() from LangGraph. The agent automatically routes Retable tool calls through the MCP protocol.
4

Run with any LLM
Swap ChatOpenAI for ChatAnthropic, ChatGoogleGenerativeAI, or any LangChain-compatible model. The MCP tools work identically across all providers.

agent.py

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

async with MultiServerMCPClient({
    "retable-mcp": {
        "transport": "http",
        "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp",
    }
}) as client:
    tools = client.get_tools()

    agent = create_react_agent(
        ChatOpenAI(model="gpt-4o"),
        tools,
    )
    result = await agent.ainvoke({
        "messages": "List recent Retable transactions"
    })
    print(result["messages"][-1].content)

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Retable. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Retable now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Retable MCP in LangChain

You use the MultiServerMCPClient from the LangChain MCP adapter package to fetch the tools and pass them to your agent constructor. The client pulls tools like `create_record` and `list_records` so your agent can call them during its execution loop.

Yes, the agent can use `list_records` to find stale entries and then call `delete_record` to remove them. You can construct a chain that evaluates rows against specific criteria before executing the deletion.

You configure rate-limiting middleware or retry logic within your LangChain runnable chains to handle API limits gracefully. When tools like `update_record` return rate-limit errors, the chain pauses and retries based on your backoff policy.

You can mix this MCP Server with any of LangChain's 500+ integrations in the same stateful graph. Your agent can pull data from an external API and immediately write it to a sheet using `create_record`.

Your relational spreadsheet data remains completely isolated within Vinkius's secure sandboxed environment. The LangChain client connects via a single secure token, meaning your raw database credentials are never exposed to the LLM or external networks.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript