Deep Agents (Beta)

npm install @raindrop-ai/deep-agents @langchain/core @langchain/anthropic deepagents

pnpm add @raindrop-ai/deep-agents @langchain/core @langchain/anthropic deepagents

pip install raindrop-deep-agents deepagents langchain-core langchain-openai

import { createDeepAgent } from "deepagents";
import { ChatAnthropic } from "@langchain/anthropic";
import { createRaindropDeepAgents } from "@raindrop-ai/deep-agents";

const raindrop = createRaindropDeepAgents({
  writeKey: "your-write-key",
  userId: "user-123",
  convoId: "session-abc",
});

const agent = createDeepAgent({
  model: new ChatAnthropic({ model: "claude-sonnet-4-6" }),
  tools: [/* filesystem, shell, etc. */],
});

const result = await agent.invoke(
  { messages: [{ role: "user", content: "Create a hello world file" }] },
  { callbacks: [raindrop.handler] },
);

await raindrop.shutdown();

from raindrop_deep_agents import RaindropDeepAgents
from deepagents import create_deep_agent
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

rd = RaindropDeepAgents(
    api_key="your-write-key",
    user_id="user-123",
    convo_id="session-abc",
)

llm = ChatOpenAI(model="gpt-4o-mini")
agent = create_deep_agent(model=llm, system_prompt="Be helpful.")

result = agent.invoke(
    {"messages": [HumanMessage(content="Create a hello world file")]},
    config={"callbacks": [rd.handler]},
)

rd.shutdown()

const raindrop = createRaindropDeepAgents({
  writeKey: "your-write-key",         // Optional: omit to disable telemetry
  endpoint: "https://...",            // Optional: custom API endpoint
  userId: "user-123",                 // Optional: associate events with a user
  convoId: "session-abc",             // Optional: conversation/thread ID
  projectId: "support-prod",          // Optional: route events to a specific project (slug)
  traceChains: true,                  // Optional: create spans for chain execution (default: true)
  debug: false,                       // Optional: enable verbose logging (default: false)
});

rd = RaindropDeepAgents(
    api_key="your-write-key",        # Optional: omit to disable telemetry
    user_id="user-123",              # Optional: associate events with a user
    convo_id="session-abc",          # Optional: conversation/thread ID
    project_id="support-prod",       # Optional: route events to a specific project (slug)
    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 = createRaindropDeepAgents({
  writeKey: "your-write-key",
  projectId: "support-prod",
});

rd = RaindropDeepAgents(
    api_key="your-write-key",
    project_id="support-prod",
)

import { tool } from "@langchain/core/tools";
import { z } from "zod";

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

const agent = createDeepAgent({
  model: new ChatAnthropic({ model: "claude-sonnet-4-6" }),
  tools: [getWeather],
});

from langchain_core.tools import tool

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

agent = create_deep_agent(
    model=ChatOpenAI(model="gpt-4o-mini"),
    tools=[get_weather],
)

await agent.invoke(
  { messages: [{ role: "user", content: "Hello" }] },
  {
    callbacks: [raindrop.handler],
    tags: ["production", "v2"],
    metadata: { feature: "onboarding", experimentId: "exp-42" },
  },
);

agent.invoke(
    {"messages": [HumanMessage(content="Hello")]},
    config={
        "callbacks": [rd.handler],
        "tags": ["production", "v2"],
        "metadata": {"feature": "onboarding", "experiment_id": "exp-42"},
    },
)

await raindrop.users.identify({
  userId: "user-123",
  traits: { plan: "pro", company: "Acme", country: "US" },
});

rd.identify("user-123", traits={"plan": "pro", "company": "Acme", "country": "US"})

await agent.invoke(
  { messages: [{ role: "user", content: "..." }] },
  { callbacks: [raindrop.handler] },
);

if (raindrop.lastEventId) {
  await raindrop.signals.track({
    eventId: raindrop.lastEventId,
    name: "thumbs_up",
    type: "feedback",
    sentiment: "POSITIVE",
    comment: "user liked the answer",
  });
}

rd.track_signal(
    event_id="evt-abc",
    name="thumbs_up",
    signal_type="feedback",
    sentiment="POSITIVE",
    comment="user liked the answer",
)

// All Deep Agents invocations are already async in TypeScript.
const result = await agent.invoke(
  { messages: [{ role: "user", content: "Hello" }] },
  { callbacks: [raindrop.handler] },
);

result = await agent.ainvoke(
    {"messages": [HumanMessage(content="Hello")]},
    config={"callbacks": [rd.handler]},
)

const raindrop = createRaindropDeepAgents({
  writeKey: "your-write-key",
  debug: true,
});

rd = RaindropDeepAgents(api_key="your-write-key", debug=True)

await raindrop.flush();    // optional: send queued events
await raindrop.shutdown(); // flush + release resources (always at process exit)

rd.flush()      # optional: send queued events
rd.shutdown()   # flush + release resources (always at process exit)