How to Use the Jibble MCP in LangChain

Q: How do I pass Jibble tools to a LangChain agent?

Install langchain-mcp-adapters and connect to the Jibble endpoint using MultiServerMCPClient. Call client.gettools() to extract tools like listtimeentries and pass them directly to your createagent method.

Q: Can LangChain trace Jibble MCP tool calls?

Yes, every tool call like gettimeentry or listpeople is fully tracked if you use LangSmith. You'll see the exact inputs, outputs, and latency for every time-tracking query your agent executes.

Q: Can I use stateless MCP queries in LangChain?

By default, the adapter runs stateless tool calls like listgroups. If you need to maintain context across multiple Jibble queries, use client.session() to keep the session active.

Q: Is my Jibble employee data safe with this setup?

Your employee names, emails, and GPS coordinates from gettimeentry are processed in a zero-trust V8 sandbox. Vinkius secures your credential tokens and never stores the payload data returned from your HR endpoints.

Connect your LangChain chains to Jibble via MCP to audit time logs and verify locations without manual API glue code.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Jibble MCP to LangChain

Create your Vinkius account to connect Jibble to LangChain and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Jibble with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain time entries with LangChain agents

Feed Jibble data directly into your decision-making chains. Your agent can call `list_time_entries` to pull recent logs, then pass those IDs to `get_time_entry` to extract specific location data or device info. This lets you build automated audit runs where the output of one step feeds the next without hardcoded scripts. By exposing this MCP Server to your runnables, LangChain tracks every step in LangSmith. You'll see exactly when the agent decided to check a person's group using `list_groups` before pulling their hours, giving you complete visibility over your automated HR workflows.

Multi-step workforce auditing

Stop writing custom Python loops to reconcile contractor hours. Your agent can run a chain starting with `list_people` to check active contractors, find their assigned projects via `list_projects`, and pull their specific logs using `list_time_entries`. This makes complex cross-referencing dead simple. The LangChain agent decides which Jibble tool to call based on what it finds, letting you flag billing discrepancies or missing location data on the fly.

Verify location compliance automatically

Look, geofencing checks don't need manual spreadsheets. Your LangChain agent can call `list_locations` to pull authorized job sites and compare them against actual coordinates returned by `get_time_entry`. This MCP integration turns raw GPS coordinates into actionable compliance checks. You get a clear, traceable chain of logic that flags off-site clock-ins before they reach your payroll system.

Setup guide

Set up Jibble 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 Jibble 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({
    "jibble-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 Jibble 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 Jibble. 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 Jibble 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 Jibble MCP in LangChain

Install `langchain-mcp-adapters` and connect to the Jibble endpoint using `MultiServerMCPClient`. Call `client.get_tools()` to extract tools like `list_time_entries` and pass them directly to your `create_agent` method.

Yes, every tool call like `get_time_entry` or `list_people` is fully tracked if you use LangSmith. You'll see the exact inputs, outputs, and latency for every time-tracking query your agent executes.

Configure your LangChain runnables with standard backoff or retry handlers. If your agent calls `list_time_entries` too frequently during shift changes, the adapter will catch the API error so your chain can retry.

By default, the adapter runs stateless tool calls like `list_groups`. If you need to maintain context across multiple Jibble queries, use `client.session()` to keep the session active.

Your employee names, emails, and GPS coordinates from `get_time_entry` are processed in a zero-trust V8 sandbox. Vinkius secures your credential tokens and never stores the payload data returned from your HR endpoints.

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