RylvoRylvo
API Documentation

Rylvo API Reference

One endpoint. Full workflow control. Integrate stage detection, action selection, verification, and escalation into your application in minutes.

Quick Start

Make your first API call in under a minute. You need your company_id, bot_id, and API key from the dashboard.

bash
curl -X POST https://api.rylvo.com/v1/respond \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_API_KEY" \
  -d '{
    "company_id": "your_company_id",
    "bot_id": "your_bot_id",
    "session_id": "session_001",
    "workflow_id": "support_triage",
    "current_user_message": "I can't access my account."
  }'

Authentication

All API requests require an API key sent in the X-API-Key header. Create keys from your dashboard.

http
X-API-Key: rylvo_sk_live_abc123...

Security: Never expose API keys in client-side code. Always call the API from your backend.

Bot Tagging (Mandatory)

Required: Every API request must include a bot_id field. Requests without a valid bot_id will be rejected with a 422 error.

Bots are the primary organizational unit for your API usage. Each bot represents a distinct agent or use case (e.g. "Support Triage Bot", "Sales Qualifier Bot"). Create bots from your dashboard, then use the bot ID to tag every API call.

How it works

1

Create a bot

Go to Dashboard → Bots → New Bot. Give it a name and description.

2

Copy the bot ID

Each bot gets a unique ID. Copy it from the bot card.

3

Tag every API request

Include "bot_id": "your_bot_id" in the request body.

4

View per-bot analytics

Filter traces, analytics, and billing by bot.

Example request with bot_id

json
{
  "company_id": "comp_001",
  "bot_id": "bot_abc123def456",
  "session_id": "sess_001",
  "workflow_id": "support_triage",
  "current_user_message": "I can't access my account."
}

Benefits of bot tagging

Per-bot analytics

View metrics, latency, and error rates per bot

Trace grouping

Filter and search traces by bot name

Key association

Link API keys to specific bots

Access control

Manage permissions per bot

Endpoints

MethodPathDescription
POST/v1/respondPrimary decision endpoint
GET/v1/statusSystem status & model registry
GET/v1/modelsDetailed model information
GET/healthHealth check
GET/readyReadiness check

Decision API

The POST /v1/respond endpoint is the core of Rylvo. Send a user message with session context, and receive a complete workflow decision including stage prediction, next action, verification result, and response text.

Stage Detection

13 stages

Action Selection

36 actions

Verification

Pass/Warn/Fail

Escalation

Auto-detect

Request Format

json
{
  "company_id": "comp_001",
  "bot_id": "bot_abc123def456",
  "session_id": "sess_001",
  "workflow_id": "support_triage",
  "current_user_message": "The display shows error E42.",
  "current_structured_state": {
    "order_id": "ORD-12345-ABC",
    "identity_verified": true,
    "error_code": "E42"
  },
  "business_metadata": {
    "customer_tier": "premium"
  },
  "tool_mode": "auto",
  "memory_mode": "auto"
}

Required Fields

FieldTypeDescription
company_idstringYour company/tenant ID
bot_idstringBot identifier (from Dashboard → Bots)
session_idstringUnique conversation session ID
workflow_idstringWorkflow type (e.g., support_triage)
current_user_messagestringThe user's current message

Optional Fields

FieldTypeDescription
current_structured_stateobjectPre-collected state (order ID, error code)
business_metadataobjectBusiness context (tier, region)
allowed_actionsarrayRestrict to specific action IDs
prompt_idstringPrompt ID to use for this request (from Dashboard → Prompts)
tool_modestringauto | force | none
memory_modestringauto | none
callbackobjectWebhook delivery config

Response Format

json
{
  "id": "resp_a1b2c3d4e5f6",
  "workflow_id": "support_triage",
  "trace_id": "tr_def456",
  "stage_prediction": {
    "stage_id": "error_code_handling",
    "confidence": 0.92
  },
  "next_action": {
    "action_id": "lookup_error_code",
    "action_class": "tool_call",
    "confidence": 0.90,
    "rationale": "Error code detected, retrieving guidance."
  },
  "verification": {
    "status": "pass",
    "reason_codes": ["decision_verified"]
  },
  "escalation": {
    "should_escalate": false,
    "escalation_target": null,
    "reason_codes": []
  },
  "output_text": "I captured E42. Let me retrieve the matching guidance.",
  "confidence": 0.91,
  "trace_id": "tr_def456"
}

Key Response Fields

FieldDescription
stage_prediction.stage_idCurrent workflow stage
next_action.action_idSelected next action
next_action.action_classtool_call | clarification | escalation | handoff
verification.statuspass | warn | fail
escalation.should_escalateWhether human handoff is needed
output_textResponse text to show the user
confidenceCombined confidence score (0-1)
trace_idUnique ID for debugging & replay

Workflow Stages (13)

greetingInitial contact, issue intake
identity_collectionUser identity verification
account_verificationAccount identity verification
order_lookupOrder details retrieval
issue_clarificationIssue details gathering
error_code_handlingError code lookup and guidance
kb_troubleshootingKnowledge base troubleshooting
feedback_collectionUser feedback on resolution
complaint_eligibilityComplaint eligibility check
complaint_registrationFormal complaint registration
resolution_deliveryResolution delivery and confirmation
escalationHuman handoff
session_closureSession wrap-up

Error Handling

401

Authentication Error

Missing or invalid API key

404

Not Found

Company profile not found

422

Validation Error

Invalid request body

429

Rate Limited

Too many requests

500

Server Error

Internal processing error

json
// Error response format
{
  "error": {
    "type": "authentication_error",
    "message": "Missing X-API-Key header."
  }
}

Multi-Turn Example

Rylvo tracks conversation state across turns using the session_id. Each turn builds on the previous state automatically.

Turn 1 — User reports issue

bash
curl -X POST https://api.rylvo.com/v1/respond \
  -H "X-API-Key: YOUR_KEY" -H "Content-Type: application/json" \
  -d '{"company_id":"comp_001","bot_id":"bot_abc123","session_id":"conv_001","workflow_id":"support_triage","current_user_message":"My subscription renewal failed."}'
# → stage: account_verification, action: verify_account

Turn 2 — User provides order ID

bash
curl -X POST https://api.rylvo.com/v1/respond \
  -H "X-API-Key: YOUR_KEY" -H "Content-Type: application/json" \
  -d '{"company_id":"comp_001","bot_id":"bot_abc123","session_id":"conv_001","workflow_id":"support_triage","current_user_message":"My order ID is ORD-98765-XYZ"}'
# → stage: order_lookup, action: lookup_order_details

Turn 3 — User wants escalation

bash
curl -X POST https://api.rylvo.com/v1/respond \
  -H "X-API-Key: YOUR_KEY" -H "Content-Type: application/json" \
  -d '{"company_id":"comp_001","bot_id":"bot_abc123","session_id":"conv_001","workflow_id":"support_triage","current_user_message":"I want to talk to a real person."}'
# → stage: escalation, action: handoff_to_human, escalation: true

Webhooks

Receive async notifications after each decision by including a callback object in your request.

json
{
  "callback": {
    "target_url": "https://your-app.com/hooks/rylvo",
    "event_type": "workflow.decision.completed",
    "headers": { "Authorization": "Bearer your-token" },
    "include_full_response": true,
    "shared_secret": "hmac-signing-secret"
  }
}

Rate Limits

PlanMonthly RequestsRate Limit
Free1,0005 req/s
Starter50,00020 req/s
Pro500,00050 req/s
Enterprise10,000,000+Custom

Usage headers are included in every response: X-Plan-Requests-Remaining, X-RateLimit-Remaining

SDKs & Libraries

Python

python
import requests

response = requests.post(
    "https://api.rylvo.com/v1/respond",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "company_id": "comp_001",
        "bot_id": "bot_abc123def456",
        "session_id": "sess_001",
        "workflow_id": "support_triage",
        "current_user_message": "I can't access my account.",
    },
)

data = response.json()
print(f"Stage: {data['stage_prediction']['stage_id']}")
print(f"Action: {data['next_action']['action_id']}")
print(f"Response: {data['output_text']}")

JavaScript / Node.js

javascript
const response = await fetch("https://api.rylvo.com/v1/respond", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-API-Key": "YOUR_API_KEY",
  },
  body: JSON.stringify({
    company_id: "comp_001",
    bot_id: "bot_abc123def456",
    session_id: "sess_001",
    workflow_id: "support_triage",
    current_user_message: "I can't access my account.",
  }),
});

const data = await response.json();
console.log("Stage:", data.stage_prediction.stage_id);
console.log("Action:", data.next_action.action_id);
console.log("Response:", data.output_text);

Prompts

Prompts are the instructions your agents follow at runtime. Create them from the Prompts dashboard, assign them to bots, and optionally enable self-improving optimization.

Key Concepts

Agent Categories

8 categories: Response Composer, Stage Classifier, Action Selector, Escalation Classifier, Session Summarizer, Verifier, Retrieval, Custom

Placeholders

Use {{key}} syntax for dynamic values resolved at runtime (company name, tone, language, etc.)

Self-Improving

Toggle auto-optimization to let the system generate, evaluate, and promote better prompt variants

Bot Assignment

Assign prompts to specific bots, or leave shared across all bots

Creating a Prompt

1

Choose an agent category

Select what type of agent this prompt controls (e.g., Response Composer, Verifier).

2

Write your prompt content

Use {{placeholder_key}} syntax for dynamic values. Templates are provided for each category.

3

Add placeholders

Define keys, labels, default values, and whether they're required. Use the template library for common ones.

4

Assign to a bot (optional)

Link the prompt to a specific bot, or leave it shared. Tag requests with prompt_id in the API.

5

Enable self-improving (optional)

Toggle auto-optimization in the prompt detail panel. Choose a strategy, metric, and frequency.

Placeholder Syntax

Placeholders use double-brace syntax: {{key}}. At runtime, they are resolved with values from the API request or defaults.

text
You are a support agent for {{company_name}}.

Greet the user as {{user_name}} in a {{tone}} tone.
Respond in {{language}}. Keep replies under {{max_length}} tokens.

{{context}}

Built-in Placeholder Templates

KeyDefaultDescription
{{company_name}}Acme CorpThe customer's company name
{{user_name}}JohnThe end user's display name
{{product_name}}Widget ProThe product being discussed
{{industry}}TechnologyThe customer's industry vertical
{{tone}}professionalResponse tone (formal, casual, empathetic)
{{language}}EnglishResponse language
{{max_length}}256Maximum response length in tokens
{{context}}Additional context for the prompt

Version History

Every edit to a prompt creates a new version. Versions are tracked as manual or auto_optimized. You can view, compare, and promote any version to active from the prompt detail panel.

Self-Improving Prompts

Rylvo implements research-backed automatic prompt optimization. When enabled, the system continuously generates, evaluates, and selects better prompt variants using real performance data.

How It Works

1. Collect

The system gathers performance metrics from real API requests that use this prompt — success rate, verification pass rate, user satisfaction signals, and latency.

2. Generate

An optimizer LLM analyzes scored prompt history and proposes N improved variants. Each variant preserves all placeholders and the core intent, but tries a different improvement strategy.

3. Evaluate

Each variant is scored against your chosen metric. Scoring uses structural analysis, constraint quality, and historical performance patterns.

4. Select

The best-performing variant is identified. It must beat the current prompt by at least the improvement threshold (default 2%) to qualify.

5. Promote or Suggest

If auto-promote is on, the winner automatically becomes the active prompt. Otherwise, it appears in version history for manual review.

Optimization Strategies

Four research-backed strategies are available. Each uses a different approach to prompt improvement.

OPRO

Yang et al., 2023 — Google DeepMind

Optimization by PROmpting. Feeds scored (prompt, performance) history to an LLM which proposes improved variants. Core insight: LLMs can act as optimizers when given examples with scores.

Best when you have version history with diverse scores.

APE

Zhou et al., 2023 — University of Toronto

Automatic Prompt Engineer. Generates diverse candidates using multiple improvement strategies (explicit instructions, examples, restructuring, guardrails, simplification), evaluates each, selects the best.

Best for new prompts with little history.

DSPy Bootstrap

Khattab et al., 2023 — Stanford

Compiles the best-performing patterns from history into optimized few-shot demonstrations. Extracts what works and bakes it directly into the prompt as examples.

Best when high-scoring versions exist to learn from.

PromptBreeder

Fernando et al., 2023 — Google DeepMind

Self-referential evolution. Applies mutation-prompts (make concise, add constraints, restructure, add reasoning, add role-playing) to evolve the task-prompt. The mutations themselves can evolve.

Best for creative exploration of prompt space.

Configuration Options

OptionDefaultDescription
StrategyOPROWhich optimization algorithm to use
Evaluation MetricSuccess Ratesuccess_rate | verification_pass | user_satisfaction | latency
Run FrequencyDailyhourly | daily | weekly | manual
Auto-PromoteOffAutomatically promote winning variants to active
Improvement Threshold2%Minimum improvement required to qualify as a winner
Max Variants Per Run5Number of candidate variants generated per optimization run
Min Sample Size50Minimum API requests before first optimization run

Enabling Self-Improvement

1

Open the prompt detail panel

Click on any prompt from the Prompts page to view its details.

2

Expand 'Self-Improving Optimization'

Click the panel header to expand the optimization settings.

3

Toggle 'Enable Auto-Improvement'

This activates the optimization loop for this prompt.

4

Choose your strategy

Select OPRO, APE, DSPy Bootstrap, or PromptBreeder depending on your needs.

5

Set your metric and frequency

Choose what to optimize for and how often to run.

6

Decide on auto-promote

Turn on to automatically deploy winning variants, or leave off for manual review.

Prompt API Usage

Use prompts programmatically by including a prompt_id in your API requests. The system resolves the active prompt version, substitutes placeholders, and uses the resulting text.

Using a Prompt in API Requests

Add the prompt_id field to your POST /v1/respond request. Optionally pass prompt_overrides to override placeholder defaults.

json
{
  "company_id": "comp_001",
  "bot_id": "bot_abc123def456",
  "session_id": "sess_001",
  "workflow_id": "support_triage",
  "prompt_id": "prompt_xyz789",
  "prompt_overrides": {
    "company_name": "Acme Corp",
    "tone": "empathetic",
    "language": "Spanish",
    "max_length": "512"
  },
  "current_user_message": "I can't access my account."
}

Prompt Resolution Flow

1

Lookup

System finds the prompt by ID and loads the active version.

2

Substitute

All {{placeholder}} values are replaced with prompt_overrides or defaults.

3

Inject

The resolved prompt is injected into the agent's system prompt for this request.

4

Track

The request is tagged with the prompt_id and version for analytics and optimization.

Python Example

python
import requests

response = requests.post(
    "https://api.rylvo.com/v1/respond",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "company_id": "comp_001",
        "bot_id": "bot_abc123def456",
        "session_id": "sess_001",
        "workflow_id": "support_triage",
        "prompt_id": "prompt_xyz789",
        "prompt_overrides": {
            "company_name": "Acme Corp",
            "tone": "empathetic",
            "language": "English",
        },
        "current_user_message": "My subscription renewal failed.",
    },
)

data = response.json()
print(f"Used prompt version: v{data.get('prompt_version', 'N/A')}")
print(f"Response: {data['output_text']}")

JavaScript / Node.js Example

javascript
const response = await fetch("https://api.rylvo.com/v1/respond", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-API-Key": "YOUR_API_KEY",
  },
  body: JSON.stringify({
    company_id: "comp_001",
    bot_id: "bot_abc123def456",
    session_id: "sess_001",
    workflow_id: "support_triage",
    prompt_id: "prompt_xyz789",
    prompt_overrides: {
      company_name: "Acme Corp",
      tone: "empathetic",
      language: "English",
    },
    current_user_message: "My subscription renewal failed.",
  }),
});

const data = await response.json();
console.log("Prompt version:", data.prompt_version);
console.log("Response:", data.output_text);

Prompt Management from Code

You can also manage prompts programmatically via the Firestore SDK if you have the Firebase credentials, or use the dashboard API.

javascript
// Create a prompt via the Rylvo dashboard Firestore SDK
import { createPrompt } from "@/lib/db/prompts";

const { promptId } = await createPrompt(orgId, userId, {
  name: "Support Triage System Prompt",
  description: "Main system prompt for the support triage bot",
  agentCategory: "response_composer",
  content: "You are a support agent for {{company_name}}...\n\nRespond in {{language}}.",
  placeholders: [
    { key: "company_name", label: "Company", description: "Customer company", defaultValue: "Acme", required: true },
    { key: "language", label: "Language", description: "Response language", defaultValue: "English", required: false },
  ],
  botId: "bot_abc123",
  botName: "Support Bot",
  tags: ["support", "triage"],
});

console.log("Created prompt:", promptId);

// Enable self-improving optimization
import { updateOptimizationConfig } from "@/lib/db/prompts";

await updateOptimizationConfig(orgId, promptId, {
  enabled: true,
  strategy: "opro",
  evaluationMetric: "success_rate",
  runFrequency: "daily",
  autoPromote: false,
});

// Manually trigger optimization
import { runOptimization } from "@/lib/services/promptOptimizer";

const result = await runOptimization(orgId, promptId, userId);
console.log("Improved:", result.improved);
console.log("Best score:", result.bestVariantScore);
console.log("Current score:", result.currentScore);

Firestore Data Structure

Prompts are stored in Firestore under the organization's subcollections:

text
organizations/{orgId}/prompts/{promptId}
  ├── name, slug, description, agentCategory
  ├── content (active prompt text)
  ├── placeholders[] (key, label, defaultValue, required)
  ├── status (draft | active | archived)
  ├── optimization { enabled, strategy, metric, frequency, ... }
  ├── activeVersionId, versionCount
  ├── botId, botName, tags[]
  └── versions/{versionId}
        ├── versionNumber, content, placeholders[]
        ├── source (manual | auto_optimized)
        ├── metrics { sampleSize, successRate, verificationPass, avgLatencyMs }
        └── changeNote, promotedAt

Edge Case Engine

Automatically detect, classify, and fix bot failure modes

The Edge Case Engine is a closed-loop system that monitors your bot traces, automatically discovers failure patterns, classifies them into categories, and suggests fixes. It uses a 5-stage pipeline: Observe → Detect → Classify → Fix → Verify.

How It Works

  1. Scan Traces — Click "Scan Traces" to analyze recent API traces for failures
  2. Auto-Detect — Engine identifies verification failures, missed escalations, hallucinations, etc.
  3. Classify — Issues are grouped into 12 categories with severity levels
  4. Fix Proposals — Engine suggests guardrails, prompt edits, or threshold changes
  5. Verify — Monitor whether fixes reduce the failure rate over time

Edge Case Categories

  • Hallucination — Response not grounded in KB evidence
  • Policy Violation — Broke company/workflow policy
  • Missed Escalation — Should have escalated but didn't
  • Wrong Tool — Selected incorrect tool for the task
  • PII Leak — Exposed sensitive personal information
  • Loop Detected — Bot stuck in repetitive pattern
  • Tone Violation — Response doesn't match brand guidelines
  • Unknown Intent — User intent not covered by any workflow

Bot-Scoped Filtering

Use the bot filter dropdown in the Edge Cases header to scope all data to a specific bot. This filters edge cases, guardrails, red team runs, and fix proposals to show only issues for that bot. Useful when managing multiple bots with different use cases.

text
Firestore: organizations/{orgId}/edgeCases/{edgeCaseId}
  ├── title, description, category, severity, status
  ├── botId, botName (scope to specific bot)
  ├── source (trace_mining | red_team | manual | guardrail_trigger)
  ├── traceIds[], occurrenceCount
  ├── sampleInput, sampleOutput, expectedBehavior
  ├── fixProposalId, guardrailId
  └── tags[], assignedTo, resolvedBy

Guardrails

Programmable safety rules that run on every bot response

Guardrails are runtime rules that check bot inputs/outputs and take action when conditions are met. They can be created manually or auto-suggested by the Edge Case Engine when it detects failure patterns.

Guardrail Types

  • Input Filter — Validates user input before processing
  • Output Filter — Validates bot response before delivery
  • Fact Check — Verifies claims against knowledge base
  • Policy Check — Ensures compliance with company policies
  • PII Detection — Detects and redacts sensitive data
  • Tone Check — Validates tone matches brand
  • Loop Breaker — Breaks repetitive conversation patterns
  • Escalation Override — Forces escalation on conditions
  • Tool Gate — Controls tool access in specific contexts

Actions

  • Block — Prevent response, return fallback message
  • Warn — Flag for review but allow response through
  • Rewrite — Auto-modify response to comply
  • Escalate — Trigger human handoff immediately
  • Log — Record for monitoring, no action taken

Each guardrail has conditions (field + operator + value) and a fallback message shown when triggered.

Red Team Testing

Proactively discover vulnerabilities with adversarial tests

Red Team runs generate adversarial inputs against your bot to find failures before users do. Select a bot, choose attack strategies, and the engine generates test cases automatically. Results are converted into edge cases with severity levels.

Attack Strategies

  • Policy Probe — Tests policy boundary conditions with edge-case inputs
  • Hallucination Bait — Questions with no KB answer to test grounding
  • Tool Confusion — Inputs that could trigger wrong tool selection
  • Escalation Boundary — Tests the edge of escalation thresholds
  • Injection Attempt — Prompt injection and jailbreak attempts
  • Context Overflow — Long conversations that stress memory limits

Automation & Reports

Schedule scans, connect channels, and generate automated reports

The Automation page (/dashboard/automation) lets you set up recurring jobs and notification channels. Everything runs on your chosen schedule — no manual intervention needed after setup.

Scheduled Tasks

Cron jobs that run automatically:

  • Trace Scan — Auto-scan traces for edge cases
  • Red Team Run — Periodic adversarial testing
  • Report Generation — Auto-generate analytics reports
  • Guardrail Audit — Review guardrail effectiveness

Cadences: hourly, daily, weekly, biweekly, monthly

Notification Channels

Where alerts and reports get sent:

  • Slack — Webhook integration
  • Email — Direct to team inboxes
  • Discord — Webhook integration
  • Microsoft Teams — Webhook integration
  • Custom Webhook — Any HTTP endpoint

Automated Reports

Analytics reports sent to your team:

  • 10 report sections to choose from
  • Daily, weekly, or monthly cadence
  • Filter recipients by role or custom emails
  • Scope to specific bot or all bots
  • "Generate Now" for instant snapshots
  • Includes improvements timeline + AI recommendations
text
Firestore Collections:

organizations/{orgId}/scheduledTasks/{taskId}
  ├── name, type, cadence, enabled
  ├── botId, botName
  ├── config { traceLimit, redTeamStrategies, ... }
  ├── notificationChannelIds[]
  └── lastRunAt, lastRunStatus, runCount, failCount

organizations/{orgId}/notificationChannels/{channelId}
  ├── name, type (slack | email | webhook | discord | teams)
  ├── config { webhookUrl, emails[], headers }
  └── events[], enabled, lastStatus

organizations/{orgId}/reportConfigs/{configId}
  ├── name, cadence, enabled
  ├── botId, sections[], recipientFilter
  └── customRecipientEmails[], notificationChannelIds[]

organizations/{orgId}/reports/{reportId}   (immutable)
  ├── configId, configName, periodStart, periodEnd
  ├── data { totalEdgeCases, bySeverity, improvements[], recommendations[] }
  └── distributedTo[], status

Webhook Connectors

Connectors let Rylvo call your systems during workflow execution. Register webhook endpoints for tool calls, state sync, or event notifications — Rylvo handles auth, retry, and signing.

Three connector types

Tool

Execute actions on your systems (create case, look up order, check inventory)

State Sync

Read/write workflow state from your DB before and after decisions

Event

Receive notifications on escalation, stage change, verification failure

Register a tool connector

bash
curl -X POST https://api.rylvo.com/v1/connectors \
  -H "X-API-Key: YOUR_KEY" -H "Content-Type: application/json" \
  -d '{
    "company_id": "comp_001",
    "connector_type": "tool",
    "name": "Salesforce Case Creator",
    "auth": {
      "auth_type": "api_key",
      "api_key_header": "X-Salesforce-Key",
      "api_key_value": "your_salesforce_api_key"
    },
    "tool_config": {
      "tool_name": "create_salesforce_case",
      "tool_description": "Create a case in Salesforce",
      "input_schema": { "type": "object", "properties": { "issue_summary": { "type": "string" } } }
    },
    "endpoint": { "url": "https://your-app.com/rylvo/tools/create-case", "method": "POST" }
  }'

API endpoints

MethodPathDescription
POST/v1/connectorsCreate connector
GET/v1/connectors/{company_id}List connectors
GET/v1/connectors/{company_id}/{id}Get detail
PATCH/v1/connectors/{company_id}/{id}Update
DELETE/v1/connectors/{company_id}/{id}Delete
POST.../{id}/activateActivate
POST.../{id}/deactivateDeactivate
POST.../{id}/testTest endpoint
POST/v1/connectors/generate-secretGenerate HMAC secret
GET/v1/connectors/{company_id}/tools/availableList webhook tools

7 authentication methods

noneapi_keybearer_tokenhmac_sha256basicoauth2_client_credentialscustom_header

10 subscribable event types

workflow.decision.completedworkflow.decision.failedworkflow.escalation.triggeredworkflow.stage.changedtool.execution.completedtool.execution.failedstate.updatedverification.failedsession.startedsession.closed

Connector Python SDK

Typed convenience methods for all connector operations. Sync and async variants included.

python
from core.connectors.sdk import ConnectorSDK

sdk = ConnectorSDK(base_url="https://api.rylvo.com", api_key="rylvo_sk_live_...")

# Register a tool connector
connector = sdk.create_tool_connector(
    company_id="comp_001",
    name="Salesforce Case Creator",
    endpoint_url="https://your-app.com/rylvo/tools/create-case",
    tool_name="create_salesforce_case",
    tool_description="Create a case in Salesforce",
    auth_type="api_key",
    api_key_header="X-Salesforce-Key",
    api_key_value="your_salesforce_api_key",
)

# Test + activate
test = sdk.test_connector("comp_001", connector["connector_id"])
if test["success"]:
    sdk.activate("comp_001", connector["connector_id"])

# List available tools
tools = sdk.list_available_tools("comp_001")
print(f"{tools['total']} webhook tools available")

Async variant

python
from core.connectors.sdk import AsyncConnectorSDK

async with AsyncConnectorSDK(base_url="...", api_key="...") as sdk:
    connector = await sdk.create_event_connector(
        company_id="comp_001",
        name="Slack Alerts",
        endpoint_url="https://hooks.slack.com/...",
        event_types=["workflow.escalation.triggered"],
    )
    await sdk.activate("comp_001", connector["connector_id"])

Error handling

ConnectorNotFoundError(404)Connector does not exist
ConnectorAuthError(401/403)Invalid or missing API key
ConnectorValidationError(422)Invalid connector configuration
ConnectorSDKError(5xx)Base class for all SDK errors

Knowledge Base

Connect your data sources to Rylvo for grounded, evidence-backed decisions. The KB system provides hybrid retrieval with 12 pre-built blueprints covering common enterprise patterns.

How it works

1

Add a source

Upload documents, connect APIs, or point to URLs. 15 source types supported.

2

Pick a blueprint

Choose from 12 retrieval blueprints (FAQ, Policy Lookup, Troubleshooting, etc.) or create custom.

3

Create a connection

A connection links a source to a blueprint with specific pipeline settings.

4

Query in playground

Test retrieval quality before going live. Tune chunking, reranking, and thresholds.

Built-in blueprints

FAQ RetrievalPolicy LookupTroubleshooting GuideProduct CatalogLegal / ComplianceOnboarding DocsMedical ReferenceFinancial AdvisoriesHR HandbookTechnical ManualsSales PlaybookCustom Pipeline

Dashboard features

Connections

Create, monitor, pause, and delete knowledge base connections

Sources

Manage 15 source types — file upload, API, URL, database

Blueprints

Pre-built and custom retrieval pipeline configurations

Playground

Test queries, inspect retrieved chunks, tune settings live

Performance

Retrieval quality metrics, latency, and hit rates

Settings

Auto-tune, chunking config, reranking, and threshold tuning

Ready to integrate?

Create an account, generate an API key, and start making decisions.