LangChain (Beta)

npm install @raindrop-ai/langchain @langchain/core @langchain/openai

pnpm add @raindrop-ai/langchain @langchain/core @langchain/openai

pip install raindrop-langchain langchain-core langchain-openai

import { createRaindropLangChain } from "@raindrop-ai/langchain";
import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage } from "@langchain/core/messages";

const raindrop = createRaindropLangChain({
  writeKey: "your-write-key",
  userId: "user-123",
});

const model = new ChatOpenAI({ model: "gpt-4o" });

const result = await model.invoke(
  [new HumanMessage("What is the capital of France?")],
  { callbacks: [raindrop.handler] },
);

await raindrop.flush();

from raindrop_langchain import create_raindrop_langchain
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

raindrop = create_raindrop_langchain(
    api_key="your-write-key",
    user_id="user-123",
)

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

result = model.invoke(
    [HumanMessage(content="What is the capital of France?")],
    config={"callbacks": [raindrop.handler]},
)

raindrop.flush()

const raindrop = createRaindropLangChain({
  writeKey: "your-write-key",                // Optional: your Raindrop write key (omit to disable telemetry)
  endpoint: "...",                   // Optional: custom API endpoint
  userId: "user-123",               // Optional: associate events with a user
  convoId: "convo-456",             // Optional: conversation/thread ID
  projectId: "support-prod",        // Optional: route events to a specific project (slug)
  eventName: "support_agent",       // Optional: event name for every event (default: "ai_generation")
  debug: false,                      // Optional: enable verbose logging
  traceChains: true,                 // Optional: create spans for chain execution (default: true)
  traceRetrievers: true,             // Optional: create spans for retriever calls (default: true)
  filterLangGraphInternals: true,    // Optional: filter LangGraph noise + dedup (default: true)
});

raindrop = create_raindrop_langchain(
    api_key="your-write-key",                    # Optional: your Raindrop API key (omit to disable telemetry)
    user_id="user-123",                 # Optional: associate events with a user
    convo_id="convo-456",               # Optional: conversation/thread ID
    project_id="support-prod",          # Optional: route events to a specific project (slug)
    event_name="support_agent",          # Optional: event name for every event (default: "ai_generation")
    trace_chains=True,                   # Optional: track chain execution (default: True)
    trace_retrievers=True,               # Optional: track retriever calls (default: True)
    filter_langgraph_internals=True,     # Optional: filter LangGraph noise + dedup (default: True)
    tracing_enabled=True,                # Optional: enable distributed tracing (default: True)
    bypass_otel_for_tools=True,          # Optional: bypass OTEL for tool spans (default: True)
    debug=False,                         # Optional: enable debug logging (default: False)
)

const raindrop = createRaindropLangChain({
  writeKey: "your-write-key",
  eventName: "support_agent",
});

raindrop = create_raindrop_langchain(
    api_key="your-write-key",
    event_name="support_agent",
)

const raindrop = createRaindropLangChain({
  writeKey: "your-write-key",
  projectId: "support-prod",
});

raindrop = create_raindrop_langchain(
    api_key="your-write-key",
    project_id="support-prod",
)

import { createRaindropLangChain } from "@raindrop-ai/langchain";
import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage } from "@langchain/core/messages";
import { StateGraph, MessagesAnnotation, END } from "@langchain/langgraph";
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

const raindrop = createRaindropLangChain({
  writeKey: "your-write-key",
  userId: "user-123",
  convoId: "convo-456",
});

const getWeather = tool(
  async ({ city }) => `The weather in ${city} is 22°C.`,
  { name: "get_weather", description: "Get weather", schema: z.object({ city: z.string() }) },
);

const model = new ChatOpenAI({ model: "gpt-4o-mini" }).bindTools([getWeather]);

const callModel = async (state: typeof MessagesAnnotation.State) => {
  const response = await model.invoke(state.messages, {
    callbacks: [raindrop.handler],
  });
  return { messages: [response] };
};

const graph = new StateGraph(MessagesAnnotation)
  .addNode("agent", callModel)
  .addNode("tools", new ToolNode([getWeather]))
  .addEdge("__start__", "agent")
  .addConditionalEdges("agent", (state) => {
    const last = state.messages[state.messages.length - 1];
    if ("tool_calls" in last && Array.isArray(last.tool_calls) && last.tool_calls.length > 0) return "tools";
    return END;
  })
  .addEdge("tools", "agent")
  .compile();

// Pass callbacks only to the model inside the node — NOT to graph.invoke().
// This ensures clean, deduplicated events without LangGraph internal noise.
const result = await graph.invoke(
  { messages: [new HumanMessage("What's the weather in Paris?")] },
);

await raindrop.shutdown();

from raindrop_langchain import create_raindrop_langchain
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
from langchain_core.tools import tool
from langgraph.graph import StateGraph, MessagesState, END
from langgraph.prebuilt import ToolNode

raindrop = create_raindrop_langchain(
    api_key="your-write-key",
    user_id="user-123",
    convo_id="convo-456",
)

@tool
def get_weather(city: str) -> str:
    """Get the weather for a city."""
    return f"The weather in {city} is 22°C."

model = ChatOpenAI(model="gpt-4o-mini").bind_tools([get_weather])

def call_model(state: MessagesState):
    response = model.invoke(
        state["messages"],
        config={"callbacks": [raindrop.handler]},
    )
    return {"messages": [response]}

def should_continue(state: MessagesState):
    last = state["messages"][-1]
    if hasattr(last, "tool_calls") and last.tool_calls:
        return "tools"
    return END

graph = (
    StateGraph(MessagesState)
    .add_node("agent", call_model)
    .add_node("tools", ToolNode([get_weather]))
    .add_edge("__start__", "agent")
    .add_conditional_edges("agent", should_continue)
    .add_edge("tools", "agent")
    .compile()
)

# Pass callbacks only to the model inside the node — NOT to graph.invoke().
result = graph.invoke(
    {"messages": [HumanMessage(content="What's the weather in Paris?")]},
)

raindrop.shutdown()

import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const prompt = ChatPromptTemplate.fromTemplate("Tell me about {topic}");
const chain = prompt.pipe(model).pipe(new StringOutputParser());

const result = await chain.invoke(
  { topic: "quantum computing" },
  { callbacks: [raindrop.handler] },
);

await raindrop.flush();

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template("Tell me about {topic}")
chain = prompt | model | StrOutputParser()

result = chain.invoke(
    {"topic": "quantum computing"},
    config={"callbacks": [raindrop.handler]},
)

raindrop.flush()

raindrop.users.identify({ userId: "user-123", traits: { name: "Alice", plan: "pro" } });

raindrop.identify("user-123", {"name": "Alice", "plan": "pro"})

raindrop.signals.track({
  eventId: "evt-abc",
  name: "thumbs_up",
  type: "feedback",
  sentiment: "POSITIVE",
});

raindrop.track_signal(
    event_id="evt-abc",
    name="thumbs_up",
    signal_type="feedback",
    sentiment="POSITIVE",
)

await raindrop.flush();     // flush pending data
await raindrop.shutdown();  // flush + release resources

raindrop.flush()     # flush pending data
raindrop.shutdown()  # flush + release resources