LangChain / LangGraph

Cachecore works with LangChain and LangGraph because they use the OpenAI SDK internally. Configure openai_api_base on ChatOpenAI and all LLM calls route through the caching gateway.

LangChain

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-5.4-mini",
    openai_api_base="https://api.cachecore.it/v1",
    openai_api_key="cc_live_xxxxx.eyJ...",
)

response = llm.invoke("Classify this support ticket as: billing, technical, or general.")
print(response.content)

LangGraph agents

LangGraph nodes that invoke LLMs benefit from caching automatically. Tool selection, classification, and routing steps repeat frequently across agent runs.

from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END
from typing import TypedDict

llm = ChatOpenAI(
    model="gpt-5.4-mini",
    openai_api_base="https://api.cachecore.it/v1",
    openai_api_key="cc_live_xxxxx.eyJ...",
)

class State(TypedDict):
    ticket: str
    category: str

def classify(state: State) -> State:
    result = llm.invoke(
        f"Classify this ticket as billing, technical, or general: {state['ticket']}"
    )
    return {"category": result.content.strip()}

graph = StateGraph(State)
graph.add_node("classify", classify)
graph.set_entry_point("classify")
graph.add_edge("classify", END)

app = graph.compile()

The classify node caches responses for repeated or similar tickets, saving tokens and latency on every run.

What caches well in LangChain workloads

Call type	Cache effectiveness	Why
Classification	High	Same structure, varying inputs, semantic matches
Tool routing	High	Limited set of intents map to tools
Document summarisation	High	Same chunks produce same summaries
Multi-turn conversation	Low	Full message history changes every turn

See Caching for AI Agents for a deeper analysis.

Dependency invalidation

LangChain does not expose httpx transport injection directly. For full dependency invalidation support, either:

Use the Python Client with the OpenAI SDK directly for LLM calls that need dep tagging
Call the invalidation API via HTTP when your data changes

# Invalidate after a data change, independent of LangChain
from cachecore import CachecoreClient

cc = CachecoreClient(
    gateway_url="https://api.cachecore.it",
    tenant_jwt="cc_live_xxxxx.eyJ...",
)

await cc.invalidate("doc:contract-123", new_hash="v2")

Constraints

LangChain's ChatOpenAI does not support custom httpx transports, so the CachecoreTransport injection pattern from the Python Client page cannot be used directly. The base URL swap still provides L1 + L2 caching.