Raindrop

https://www.raindrop.ai/docs
Admin
Raindrop is a monitoring platform for AI agents that detects silent agent failures in production,...
Tokens:134,174
Snippets:1,458
Trust Score:7.5
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Raindrop Go SDK

Source: https://www.raindrop.ai/docs/sdk/go

Use the go get command to add the Raindrop SDK to your project.

```bash
go get github.com/raindrop-ai/go
```

--------------------------------

### Install Raindrop setup skill

Source: https://www.raindrop.ai/docs/integrations/overview

Use the npx command to add the raindrop-setup skill to your project for automated instrumentation.

```bash
npx skills add raindrop-ai/skills --skill raindrop-setup
```

--------------------------------

### Install @raindrop-ai/ai-sdk

Source: https://www.raindrop.ai/docs/integrations/vercel-ai-sdk

Install the package using your preferred package manager.

```bash
npm install @raindrop-ai/ai-sdk
```

```bash
yarn add @raindrop-ai/ai-sdk
```

```bash
pnpm add @raindrop-ai/ai-sdk
```

```bash
bun add @raindrop-ai/ai-sdk
```

--------------------------------

### Install Azure OpenAI Integration

Source: https://www.raindrop.ai/docs/integrations/azure-openai

Install the required packages for your environment.

```bash
npm install @raindrop-ai/azure-openai openai
```

```bash
pnpm add @raindrop-ai/azure-openai openai
```

```bash
pip install raindrop-azure-openai openai
```

--------------------------------

### Install Vertex AI SDK

Source: https://www.raindrop.ai/docs/integrations/vertex-ai

Install the required packages for your environment using npm or pip.

```bash
npm install @raindrop-ai/vertex-ai @google/genai
```

```bash
pip install raindrop-vertex-ai google-genai
```

--------------------------------

### Install Raindrop Bedrock SDK

Source: https://www.raindrop.ai/docs/integrations/bedrock

Install the necessary packages for your environment to enable tracing.

```bash
npm install @raindrop-ai/bedrock @aws-sdk/client-bedrock-runtime
```

```bash
pnpm add @raindrop-ai/bedrock @aws-sdk/client-bedrock-runtime
```

```bash
pip install raindrop-bedrock boto3
```

--------------------------------

### Install Raindrop Workshop

Source: https://www.raindrop.ai/docs/workshop/overview

Use this command to install the Raindrop CLI tool on your machine.

```bash
curl -fsSL https://raindrop.sh/install | bash
```

--------------------------------

### Install OpenAI Agents SDK

Source: https://www.raindrop.ai/docs/integrations/openai-agents

Use these commands to install the necessary packages for your project environment.

```bash
npm install @raindrop-ai/openai-agents @openai/agents
```

```bash
pnpm add @raindrop-ai/openai-agents @openai/agents
```

```bash
pip install raindrop-openai-agents openai-agents
```

--------------------------------

### Run Setup Command

Source: https://www.raindrop.ai/docs/integrations/claude-code

Initialize the configuration with a write key and user ID.

```bash
raindrop-claude-code setup --write-key=YOUR_KEY --user-id=your-username
```

--------------------------------

### Install Agno and Raindrop dependencies

Source: https://www.raindrop.ai/docs/integrations/agno

Install the necessary packages to enable Raindrop tracing for Agno.

```bash
pip install raindrop-agno agno
```

--------------------------------

### Install Cursor Agent SDK

Source: https://www.raindrop.ai/docs/integrations/cursor-agent-sdk

Install the required packages using your preferred package manager.

```bash
npm install @raindrop-ai/cursor-agent-sdk @cursor/sdk
```

```bash
yarn add @raindrop-ai/cursor-agent-sdk @cursor/sdk
```

```bash
pnpm add @raindrop-ai/cursor-agent-sdk @cursor/sdk
```

```bash
bun add @raindrop-ai/cursor-agent-sdk @cursor/sdk
```

--------------------------------

### Launch Local UI

Source: https://www.raindrop.ai/docs/query-api/zdr-signals

Start the local browser playground via the CLI.

```bash
raindrop-signals ui        # serves http://127.0.0.1:4400; --port and --no-open available
```

--------------------------------

### Install Query API SDK

Source: https://www.raindrop.ai/docs/query-api/sdk

Commands to install the required SDK packages for TypeScript and Python environments.

```bash
npm install @raindrop-ai/query
```

```bash
pip install raindrop-query
```

--------------------------------

### client.Begin

Source: https://www.raindrop.ai/docs/sdk/go

Starts a new interaction session and logs the initial user input.

```APIDOC
## client.Begin

### Description
Creates an interaction and logs the initial user input.

### Signature
`func (c *Client) Begin(ctx context.Context, opts BeginOptions) Interaction`

### Parameters
- **ctx** (context.Context) - Required - The context for the operation.
- **opts** (BeginOptions) - Required - Options including EventID, UserID, Event, Input, Model, ConvoID, and Properties.
```

--------------------------------

### Install Google ADK Integration

Source: https://www.raindrop.ai/docs/integrations/google-adk

Install the necessary packages to enable Raindrop tracing for Google ADK.

```bash
pip install raindrop-google-adk google-adk
```

--------------------------------

### Install Pi Agent Package

Source: https://www.raindrop.ai/docs/integrations/pi-agent

Install the required package using npm or pnpm.

```bash
npm install @raindrop-ai/pi-agent
```

```bash
pnpm add @raindrop-ai/pi-agent
```

--------------------------------

### Install dependencies

Source: https://www.raindrop.ai/docs/integrations/claude-managed-agents

Install the required Raindrop instrumentation package and the Anthropic SDK using your preferred package manager.

```bash
npm install @raindrop-ai/claude-managed-agents @anthropic-ai/sdk
```

```bash
yarn add @raindrop-ai/claude-managed-agents @anthropic-ai/sdk
```

```bash
pnpm add @raindrop-ai/claude-managed-agents @anthropic-ai/sdk
```

```bash
bun add @raindrop-ai/claude-managed-agents @anthropic-ai/sdk
```

--------------------------------

### Quick Start with DSPy

Source: https://www.raindrop.ai/docs/integrations/dspy

Initialize the Raindrop wrapper and apply it to a DSPy module to begin tracing.

```python
import dspy
from raindrop_dspy import RaindropDSPy

raindrop = RaindropDSPy(api_key="rk_...", user_id="user-123")

lm = dspy.LM("openai/gpt-4o-mini")
dspy.configure(lm=lm)

predict = dspy.Predict("question -> answer")
wrapped = raindrop.wrap(predict)

result = wrapped(question="What is the capital of France?")
print(result.answer)

raindrop.shutdown()
```

--------------------------------

### Start an interaction with begin()

Source: https://www.raindrop.ai/docs/sdk/python

Initializes a new interaction session and returns an Interaction helper object.

```python
interaction = raindrop.begin(
    user_id="user456",
    event="chatbot_session_started",
    input="Hello chatbot!"
)
# interaction.id contains the event_id
```

--------------------------------

### Install Browser SDK

Source: https://www.raindrop.ai/docs/sdk/browser

Commands to install the Raindrop browser SDK using various package managers.

```bash
npm install @raindrop-ai/browser-sdk
```

```bash
yarn add @raindrop-ai/browser-sdk
```

```bash
pnpm add @raindrop-ai/browser-sdk
```

```bash
bun add @raindrop-ai/browser-sdk
```

--------------------------------

### Install Raindrop Signals CLI

Source: https://www.raindrop.ai/docs/query-api/zdr-signals

Use the installation script to download and configure the CLI. Requires Node.js 20 or newer.

```bash
curl -fsSL https://query.raindrop.ai/v1/cli/install.sh | bash
```

```bash
export RAINDROP_API_KEY="YOUR_API_KEY"
curl -fsSL https://query.raindrop.ai/v1/cli/install.sh | bash
```

--------------------------------

### Setup Agent Replay

Source: https://www.raindrop.ai/docs/workshop/overview

Configure your agent to support trace replays for testing changes.

```text
/setup-agent-replay
```

--------------------------------

### Install TanStack AI integration

Source: https://www.raindrop.ai/docs/integrations/tanstack-ai

Install the required packages for TanStack AI and the Raindrop middleware.

```bash
pnpm add @raindrop-ai/tanstack-ai @tanstack/ai @tanstack/ai-openai
```

--------------------------------

### GET /v1/cli

Source: https://www.raindrop.ai/docs/query-api/zdr-signals

Download the single-file CLI.

```APIDOC
## GET /v1/cli

### Description
Download the single-file CLI.

### Method
GET

### Endpoint
/v1/cli
```

--------------------------------

### Install Pydantic AI Integration

Source: https://www.raindrop.ai/docs/integrations/pydantic-ai

Install the necessary packages to enable Raindrop tracing for Pydantic AI.

```bash
pip install raindrop-pydantic-ai pydantic-ai
```

--------------------------------

### Define Refinement Examples

Source: https://www.raindrop.ai/docs/query-api/zdr-signals

Provide examples of matches and non-matches to clarify the signal's decision boundary.

```text
Match:    Wow, another outage. Really getting my money's worth here.
No match: Is there an outage right now? My dashboard won't load.
```

--------------------------------

### Initialize Raindrop Client

Source: https://www.raindrop.ai/docs/sdk/typescript

Basic setup for the Raindrop client using a write key from the dashboard.

```typescript
import { Raindrop } from "raindrop-ai";

// Replace with the key from your Raindrop dashboard
const raindrop = new Raindrop({ writeKey: RAINDROP_API_KEY });
```

--------------------------------

### Manage interaction lifecycle

Source: https://www.raindrop.ai/docs/sdk/python

Demonstrates starting an interaction, adding attachments, and finishing the session.

```python
# Start an interaction
interaction = raindrop.begin(user_id="user789", event="code_generation", input="Write a python function for fibonacci")

# ... later, user adds more context
interaction.add_attachments([{"type": "text", "value": "It should be recursive", "role": "input"}])

# ... AI generates output
interaction.finish(output="def fib(n): if n <= 1: return n else: return fib(n-1) + fib(n-2)")
```

--------------------------------

### interaction.startToolSpan(params)

Source: https://www.raindrop.ai/docs/sdk/typescript

Starts a real-time tool span to track execution as it happens.

```APIDOC
## interaction.startToolSpan(params)

### Description
Starts a tool span to track a tool as it executes in real-time. Returns a toolSpan object with methods to update status.

### Methods
- **setInput(input)** - Set the input (JSON stringified if object)
- **setOutput(output)** - Set the output (JSON stringified if object)
- **setError(error)** - Mark the span as failed
- **end()** - End the span (required when execution completes)
```

--------------------------------

### Install Raindrop Skills

Source: https://www.raindrop.ai/docs/integrations/skills

Use the skills CLI to add specific Raindrop skills to your project environment.

```bash
npx skills add raindrop-ai/skills --skill raindrop-setup
npx skills add raindrop-ai/skills --skill raindrop-investigate
```

--------------------------------

### Download example files via Bash

Source: https://www.raindrop.ai/docs/query-api/zdr-signals

Downloads the five required JSON files for the tutorial into the current directory.

```bash
for f in training-events.json evaluate-match.json evaluate-no-match.json \
         events-initial.json refinement-events.json; do
  curl -fsSLO "https://www.raindrop.ai/docs/files/signals-api/$f"
done
```

--------------------------------

### Track Chat Completion Interaction

Source: https://www.raindrop.ai/docs/sdk/typescript

Full lifecycle example for tracking a chat interaction, including starting, executing, and finishing the event.

```typescript
import { openai } from '@ai-sdk/openai';
import { generateText } from 'ai';
import { randomUUID } from "crypto";
import { Raindrop } from "raindrop-ai";

const raindrop = new Raindrop({ writeKey: RAINDROP_API_KEY });

const message = "What is love?";
const eventId = randomUUID(); // Generate your own ID for log correlation

// 1. Start the interaction
const interaction = raindrop.begin({
  eventId,
  event: "chat_message",
  userId: "user_123",
  input: message,
  model: "gpt-4o",
  convoId: "convo_123",
  properties: {
    tool_call: "reasoning_engine",
    system_prompt: "you are a helpful...",
    experiment: "experiment_a",
  },
});

// 2. Make the LLM call
const { text } = await generateText({
  model: openai("gpt-4o"),
  prompt: message,
});

// 3. Finish the interaction
interaction.finish({
  output: text,
});
```

--------------------------------

### GET /v1/events/count

Source: https://www.raindrop.ai/docs/query-api/api-reference

Get a count of events.

```APIDOC
## GET /v1/events/count

### Description
Retrieve the count of events.

### Method
GET

### Endpoint
/v1/events/count
```

--------------------------------

### begin(BeginOptions options)

Source: https://www.raindrop.ai/docs/sdk/java

Opens an interaction (trace) and returns an Interaction object for further updates.

```APIDOC
## begin(BeginOptions options)

### Description
Opens an interaction trace and immediately ships a pending event. Returns an Interaction object that supports chaining methods like setInput, setOutput, setModel, setProperty, and setError.

### Parameters
- **options** (BeginOptions) - Required - Configuration for the interaction including event, userId, convoId, and input.
```

--------------------------------

### Implement manual span lifecycle

Source: https://www.raindrop.ai/docs/sdk/python

Demonstrates initializing the SDK, starting a manual span, recording input/output, and handling errors.

```python
import os
import raindrop.analytics as raindrop

raindrop.init(os.getenv("RAINDROP_WRITE_KEY"), tracing_enabled=True)

@raindrop.interaction("my_workflow")
def main():
    interaction = raindrop.begin(user_id="user123", event="process_data", input="...")

    # Start a span
    span = interaction.start_span(kind="tool", name="external_api")
    span.record_input({"query": "example"})

    try:
        result = call_external_api()
        span.record_output(result)
        span.end()
    except Exception as e:
        span.end(error=e)

    interaction.finish(output="Done")
    raindrop.shutdown()
```

--------------------------------

### Install Raindrop DSPy

Source: https://www.raindrop.ai/docs/integrations/dspy

Install the necessary packages via pip.

```bash
pip install raindrop-dspy dspy
```

--------------------------------

### Initialize Raindrop Client

Source: https://www.raindrop.ai/docs/sdk/go

Create a new client instance using your write key.

```go
import raindrop "github.com/raindrop-ai/go"

client, err := raindrop.New(
	raindrop.WithWriteKey("your-write-key"),
)
if err != nil {
	log.Fatal(err)
}
defer client.Close()
```

--------------------------------

### Install Strands Agents Integration

Source: https://www.raindrop.ai/docs/integrations/strands

Install the necessary packages for the Raindrop Strands integration.

```bash
npm install @raindrop-ai/strands @strands-agents/sdk
```

```bash
yarn add @raindrop-ai/strands @strands-agents/sdk
```

```bash
pnpm add @raindrop-ai/strands @strands-agents/sdk
```

```bash
pip install raindrop-strands strands-agents
```

--------------------------------

### Install Raindrop CrewAI

Source: https://www.raindrop.ai/docs/integrations/crewai

Install the necessary packages to enable Raindrop tracing for CrewAI.

```bash
pip install raindrop-crewai crewai
```

--------------------------------

### Install Raindrop Mastra dependencies

Source: https://www.raindrop.ai/docs/integrations/mastra

Install the required packages for integrating Raindrop with Mastra.

```bash
npm install @raindrop-ai/mastra @mastra/core
```

--------------------------------

### Configure and initialize CLI

Source: https://www.raindrop.ai/docs/query-api/zdr-signals

Set environment variables for authentication and project configuration before running CLI commands.

```bash
export RAINDROP_API_KEY="YOUR_API_KEY"
export RAINDROP_PROJECT_ID="default" # optional; defaults to default
export RAINDROP_API_URL="https://query.raindrop.ai" # optional

raindrop-signals --help
```

--------------------------------

### Install Temporal SDK dependencies

Source: https://www.raindrop.ai/docs/integrations/temporal

Install the required Raindrop and Temporal packages via npm.

```bash
npm install @raindrop-ai/temporal @temporalio/client @temporalio/worker
```

--------------------------------

### Configure System Prompt and Project via JSON

Source: https://www.raindrop.ai/docs/integrations/opencode

Alternative configuration for system prompt capture and project ID using a JSON file.

```json
{
  "capture_system_prompt": true
}
```

```json
{
  "project_id": "support-prod"
}
```

--------------------------------

### Install Deep Agents dependencies

Source: https://www.raindrop.ai/docs/integrations/deepagents

Install the required packages for your environment to enable Raindrop tracing.

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

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

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

--------------------------------

### Install Pi Coding Agent CLI Extension

Source: https://www.raindrop.ai/docs/integrations/pi-agent

Install the Raindrop extension for the Pi CLI.

```bash
pi install npm:@raindrop-ai/pi-agent
```

--------------------------------

### Initialize Raindrop SDK

Source: https://www.raindrop.ai/docs/sdk/python

Basic initialization using a write key, with options for enabling tracing and bypassing OTEL exporters.

```python
import os
import raindrop.analytics as raindrop

# Recommended: load from env var
raindrop.init(os.getenv("RAINDROP_WRITE_KEY") or "YOUR_WRITE_KEY")

# Optional: enable tracing integration for task/tool decorators
# raindrop.init("YOUR_WRITE_KEY", tracing_enabled=True)

# Optional: bypass OTEL exporters for interaction.track_tool() spans only
# raindrop.init("YOUR_WRITE_KEY", tracing_enabled=True, bypass_otel_for_tools=True)
```

--------------------------------

### Install Raindrop SDK

Source: https://www.raindrop.ai/docs/sdk/python

Commands to install the raindrop-ai package using common Python package managers.

```sh
pip install raindrop-ai
```

```sh
uv add raindrop-ai
```

```sh
poetry add raindrop-ai
```

--------------------------------

### Install TypeScript OpenTelemetry Dependencies

Source: https://www.raindrop.ai/docs/sdk/opentelemetry

Installs the required OpenTelemetry SDK and OTLP HTTP exporter packages.

```bash
pnpm add @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-http
```

--------------------------------

### Auto-instrumentation shortcut

Source: https://www.raindrop.ai/docs/integrations/crewai

Use the setup_crewai helper to automatically trace all Crew.kickoff calls.

```python
from raindrop_crewai import setup_crewai

raindrop = setup_crewai(api_key="your-write-key", user_id="user-123")
# Every Crew.kickoff* call is now automatically traced.
```

--------------------------------

### setup_crewai

Source: https://www.raindrop.ai/docs/integrations/crewai

Shortcut function to auto-instrument all Crew.kickoff calls.

```APIDOC
## setup_crewai(api_key, user_id)

### Description
Automatically patches every Crew.kickoff* call on the Crew class for global tracing.

### Parameters
- **api_key** (string) - Required - API key for telemetry.
- **user_id** (string) - Required - Default user ID.
```

--------------------------------

### Install Claude Code Plugin

Source: https://www.raindrop.ai/docs/integrations/claude-code

Commands to add and install the Raindrop plugin via the Claude CLI.

```bash
claude plugin marketplace add raindrop-ai/claude-code-plugin
claude plugin install raindrop
```

--------------------------------

### Raindrop.begin()

Source: https://www.raindrop.ai/docs/sdk/typescript

Initializes a new interaction session to track user input and AI context.

```APIDOC
## begin(options)

### Description
Creates an interaction and logs the initial user input.

### Parameters
- **eventId** (string) - Required - Unique ID for log correlation.
- **event** (string) - Required - The name of the event.
- **userId** (string) - Required - The ID of the user.
- **input** (string) - Required - The initial user input.
- **model** (string) - Optional - The AI model used.
- **convoId** (string) - Optional - The conversation ID.
- **properties** (object) - Optional - Additional metadata properties.
```

--------------------------------

### Quickstart AI Event Tracking

Source: https://www.raindrop.ai/docs/sdk/browser

Initialize the Raindrop client and track single-shot or partial AI event flows.

```ts
import { Raindrop } from '@raindrop-ai/browser-sdk';

const rd = new Raindrop({ apiKey: 'DAWN_xxx' });

// 1) Single-shot AI event (camelCase fields)
const { eventIds } = await rd.trackAi({
  event: 'ai_completion',
  userId: 'user_123',
  model: 'gpt-4o',
  input: 'hello',
  output: 'hi there',
  convoId: 'convo_123',
  properties: { page: '/home' },
});
console.log('trackAi eventIds:', eventIds);

// 2) Partial AI event flow (returned object includes finish())
const eid = crypto.randomUUID();
const partial = await rd.trackAiPartial({
  eventId: eid,
  event: 'chat',
  userId: 'user_123',
  model: 'gpt-4o',
  convoId: 'convo_123',
  output: 'chunk 1',
});

await rd.trackAiPartial({ eventId: eid, output: 'chunk 2' });
const done = await partial.finish({ output: 'final answer' });
console.log('partial finished:', done);
```

--------------------------------

### Initialize Raindrop Client

Source: https://www.raindrop.ai/docs/sdk/java

Basic setup for the Raindrop client. If the write key is missing, the SDK defaults to a no-op mode to prevent application impact.

```java
import ai.raindrop.*;

public class Main {
    public static void main(String[] args) {
        // Empty / missing key → SDK becomes a no-op (zero HTTP), so you can integrate
        // the SDK code first and add the key later without affecting your app.
        Raindrop raindrop = new Raindrop(RaindropConfig.builder()
                .writeKey(System.getenv("RAINDROP_WRITE_KEY"))
                .build());

        // ... use raindrop ...

        raindrop.close();
    }
}
```

--------------------------------

### Install Eve Integration Dependencies

Source: https://www.raindrop.ai/docs/integrations/eve

Install the required Raindrop and OpenTelemetry packages to enable observability in your Eve project.

```bash
pnpm add @raindrop-ai/eve @vercel/otel @opentelemetry/api @opentelemetry/sdk-trace-base
```

--------------------------------

### Initialize Raindrop Client

Source: https://www.raindrop.ai/docs/sdk/java

Use the RaindropConfig builder to instantiate the client. Ensure the write key is provided via environment variables for security.

```java
Raindrop raindrop = new Raindrop(RaindropConfig.builder()
        .writeKey(System.getenv("RAINDROP_WRITE_KEY"))
        .redactPii(true)
        .debugLogs(!"production".equals(System.getenv("ENV")))
        .build());
```

--------------------------------

### Install LangChain SDK dependencies

Source: https://www.raindrop.ai/docs/integrations/langchain

Install the required Raindrop and LangChain packages using your preferred package manager.

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

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

```bash
pip install raindrop-langchain langchain-core langchain-openai
```

--------------------------------

### raindrop.New

Source: https://www.raindrop.ai/docs/sdk/go

Initializes a new Raindrop client instance with the provided configuration options.

```APIDOC
## raindrop.New

### Description
Creates a new client instance to interact with the Raindrop API. Use the provided functional options to configure the client.

### Signature
`func New(options ...Option) (*Client, error)`

### Configuration Options
- **WithWriteKey(string)** - Required - Your Raindrop API key.
- **WithProjectID(string)** - Optional - Send events to a specific project; defaults to "default".
- **WithDebug(bool)** - Optional - Print debug logs to the configured logger; defaults to false.
- **WithEndpoint(string)** - Optional - Override the default API endpoint.
- **WithHTTPClient(*http.Client)** - Optional - Use a custom HTTP client.
- **WithLogger(*slog.Logger)** - Optional - Use a custom slog.Logger.
- **WithServiceName(string)** - Optional - Override the service name in traces.
- **WithServiceVersion(string)** - Optional - Override the service version in traces.

### Example
```go
client, err := raindrop.New(
	raindrop.WithWriteKey("your-write-key"),
	raindrop.WithDebug(os.Getenv("ENV") != "production"),
)
```
```

--------------------------------

### Install via Package Manager

Source: https://www.raindrop.ai/docs/integrations/claude-code

Global installation of the Raindrop Claude Code package using npm, pnpm, or yarn.

```bash
npm install -g @raindrop-ai/claude-code
```

```bash
pnpm add -g @raindrop-ai/claude-code
```

```bash
yarn global add @raindrop-ai/claude-code
```

--------------------------------

### Install OpenRouter Agent SDK dependencies

Source: https://www.raindrop.ai/docs/integrations/openrouter-agent

Install the required Raindrop and OpenRouter packages using your preferred package manager.

```bash
npm install @raindrop-ai/openrouter-agent @openrouter/agent
```

```bash
pnpm add @raindrop-ai/openrouter-agent @openrouter/agent
```

```bash
yarn add @raindrop-ai/openrouter-agent @openrouter/agent
```

```bash
bun add @raindrop-ai/openrouter-agent @openrouter/agent
```

--------------------------------

### Install Claude Agent SDK package

Source: https://www.raindrop.ai/docs/integrations/claude-agent-sdk

Install the Raindrop Claude Agent SDK package using your preferred package manager.

```bash
npm install @raindrop-ai/claude-agent-sdk
```

```bash
yarn add @raindrop-ai/claude-agent-sdk
```

```bash
pnpm add @raindrop-ai/claude-agent-sdk
```

```bash
bun add @raindrop-ai/claude-agent-sdk
```

--------------------------------

### Initialize and Use Cursor Agent SDK

Source: https://www.raindrop.ai/docs/integrations/cursor-agent-sdk

Initialize the SDK and wrap the Cursor client to start capturing agent events and traces.

```typescript
import * as cursor from "@cursor/sdk";
import { createRaindropCursorAgentSDK, eventMetadata } from "@raindrop-ai/cursor-agent-sdk";

const raindrop = createRaindropCursorAgentSDK({
  writeKey: process.env.RAINDROP_WRITE_KEY,
});

const wrapped = raindrop.wrap(cursor, {
  context: eventMetadata({
    userId: "user-123",
    eventName: "cursor_agent_run",
    convoId: "conversation-1",
  }),
});

const agent = await wrapped.Agent.create({
  model: { id: "composer-1" },
});
const run = await agent.send("Summarize the repository");

for await (const message of run.stream()) {
  console.log(message);
}

await raindrop.flush();
```

--------------------------------

### Configure RaindropAgno

Source: https://www.raindrop.ai/docs/integrations/agno

Initialize the RaindropAgno wrapper with API keys, user identification, and tracing options.

```python
raindrop = RaindropAgno(
    api_key="your-write-key",           # Your Raindrop API key (optional — 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)
    tracing_enabled=True,               # Enables the Agno OpenInference instrumentor (default: True)
    bypass_otel_for_tools=True,         # Bypass OTEL for tool spans (default: True)
    debug=True,                         # Optional: enable DEBUG-level logging
)
```

--------------------------------

### GET /v1/conversations

Source: https://www.raindrop.ai/docs/query-api/api-reference

Retrieve a list of conversations.

```APIDOC
## GET /v1/conversations

### Description
Retrieve a list of conversations.

### Method
GET

### Endpoint
/v1/conversations
```

--------------------------------

### Configure Raindrop Client

Source: https://www.raindrop.ai/docs/sdk/go

Initialize the client with a write key and optional settings. Ensure client.Close() is called before process exit to flush buffers.

```go
client, err := raindrop.New(
	raindrop.WithWriteKey("your-write-key"),
	raindrop.WithDebug(os.Getenv("ENV") != "production"),
)
```

--------------------------------

### Initialize and Run Google ADK Agent

Source: https://www.raindrop.ai/docs/integrations/google-adk

Configure the Raindrop setup and execute a Google ADK runner with an agent and tool.

```python
from raindrop_google_adk import setup_google_adk
from google.adk import Runner
from google.adk.agents import LlmAgent
from google.adk.sessions import InMemorySessionService
from google.genai import types

# Enable automatic tracing for all ADK Runner interactions
rd = setup_google_adk(api_key="your-write-key")

def get_weather(city: str) -> dict:
    """Get weather for a city."""
    return {"temperature": 72, "condition": "sunny", "city": city}

agent = LlmAgent(
    name="weather_assistant",
    tools=[get_weather],
    model="gemini-2.5-flash",
    instruction="You are a helpful assistant that can check weather.",
)

session_service = InMemorySessionService()
runner = Runner(app_name="weather_app", agent=agent, session_service=session_service)

user_msg = types.Content(
    parts=[types.Part(text="What's the weather in New York?")],
    role="user",
)

for event in runner.run(user_id="user123", session_id="session123", new_message=user_msg):
    if event.is_final_response():
        print(event.content.parts[0].text)
```

--------------------------------

### GET /v1/users

Source: https://www.raindrop.ai/docs/query-api/api-reference

Retrieve a list of users.

```APIDOC
## GET /v1/users

### Description
Retrieve a list of users.

### Method
GET

### Endpoint
/v1/users
```

--------------------------------

### GET /v1/signals

Source: https://www.raindrop.ai/docs/query-api/api-reference

Retrieve a list of signals.

```APIDOC
## GET /v1/signals

### Description
Retrieve a list of signals.

### Method
GET

### Endpoint
/v1/signals
```

--------------------------------

### Initialize Client with Project ID

Source: https://www.raindrop.ai/docs/sdk/go

Use WithProjectID to scope client events to a specific project by setting the X-Raindrop-Project-Id header.

```go
client, err := raindrop.New(
	raindrop.WithWriteKey("your-write-key"),
	raindrop.WithProjectID("support-prod"),
)
```

--------------------------------

### GET /v1/traces

Source: https://www.raindrop.ai/docs/query-api/api-reference

Retrieve a list of traces.

```APIDOC
## GET /v1/traces

### Description
Retrieve a list of traces.

### Method
GET

### Endpoint
/v1/traces
```

--------------------------------

### GET /v1/events/facets

Source: https://www.raindrop.ai/docs/query-api/api-reference

Retrieve event facets.

```APIDOC
## GET /v1/events/facets

### Description
Retrieve facets for events.

### Method
GET

### Endpoint
/v1/events/facets
```

--------------------------------

### GET /v1/events/timeseries

Source: https://www.raindrop.ai/docs/query-api/api-reference

Retrieve event data as a timeseries.

```APIDOC
## GET /v1/events/timeseries

### Description
Retrieve event data formatted as a timeseries.

### Method
GET

### Endpoint
/v1/events/timeseries
```

--------------------------------

### setup_google_adk()

Source: https://www.raindrop.ai/docs/integrations/google-adk

Automatically patches all ADK Runner instances for global telemetry tracking.

```APIDOC
## setup_google_adk(api_key, user_id=None, convo_id=None, project_id=None, tracing_enabled=True, bypass_otel_for_tools=True)

### Description
Automatically patches all ADK Runner instances to enable telemetry. All subsequent `Runner.run()` and `Runner.run_async()` calls will be automatically traced.

### Parameters
- **api_key** (str) - Required - Your Raindrop API key. If None, telemetry is disabled.
- **user_id** (str) - Optional - Default user ID for all events.
- **convo_id** (str) - Optional - Conversation or thread ID.
- **project_id** (str) - Optional - Slug of the project to route events to.
- **tracing_enabled** (bool) - Optional - Enable/disable OTEL tracing (default: True).
- **bypass_otel_for_tools** (bool) - Optional - Bypass OTEL for tool calls (default: True).
```

--------------------------------

### GET /v1/events

Source: https://www.raindrop.ai/docs/query-api/api-reference

Retrieve a list of events from the system.

```APIDOC
## GET /v1/events

### Description
Retrieve a list of events. By default, this is scoped to the Production project unless specified via the X-Raindrop-Project-Id header.

### Method
GET

### Endpoint
/v1/events
```

--------------------------------

### Initialize Google ADK with Factory Functions

Source: https://www.raindrop.ai/docs/integrations/google-adk

Demonstrates auto-patching and manual wrapping of Runner instances using factory functions.

```python
from raindrop_google_adk import setup_google_adk, create_raindrop_google_adk

# Auto-patch all Runner instances
rd = setup_google_adk(api_key="your-write-key")

# Or create without auto-patching
rd = create_raindrop_google_adk(api_key="your-write-key")
wrapped = rd.wrap(runner)
```

--------------------------------

### interaction.StartToolSpan

Source: https://www.raindrop.ai/docs/sdk/go

Starts a real-time span for a tool as it executes.

```APIDOC
## interaction.StartToolSpan(name, options)

### Description
Initiates a tool span for real-time tracking during execution.

### Methods
- **SetInput(any)** - Set the input
- **SetOutput(any)** - Set the output
- **SetError(error)** - Mark the span as failed
- **End()** - End the span
```

--------------------------------

### Client::begin

Source: https://www.raindrop.ai/docs/sdk/rust

Initiates a new interaction session with the Raindrop API, logging the initial user input and event context.

```APIDOC
## Client::begin

### Description
Starts a new interaction session. This method returns an interaction handle used for subsequent updates and finalization.

### Signature
`async fn begin(&self, options: BeginOptions) -> Interaction`

### Parameters
- **options** (BeginOptions) - Required - Configuration object containing event_id, user_id, event, input, model, convo_id, and properties.
```

--------------------------------

### GET /v1/signal-definitions

Source: https://www.raindrop.ai/docs/query-api/zdr-signals

List API-created signals with build state.

```APIDOC
## GET /v1/signal-definitions

### Description
List API-created signals with build state.

### Method
GET

### Endpoint
/v1/signal-definitions
```

--------------------------------

### GET /v1/conversations/{id}

Source: https://www.raindrop.ai/docs/query-api/api-reference

Retrieve a specific conversation by its ID.

```APIDOC
## GET /v1/conversations/{id}

### Description
Retrieve details for a specific conversation by its unique identifier.

### Method
GET

### Endpoint
/v1/conversations/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the conversation.
```

--------------------------------

### GET /v1/users/{id}

Source: https://www.raindrop.ai/docs/query-api/api-reference

Retrieve a specific user by their ID.

```APIDOC
## GET /v1/users/{id}

### Description
Retrieve details for a specific user by their unique identifier.

### Method
GET

### Endpoint
/v1/users/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the user.
```
Tokens:
Raw