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.
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.
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
Create a bot
Go to Dashboard → Bots → New Bot. Give it a name and description.
Copy the bot ID
Each bot gets a unique ID. Copy it from the bot card.
Tag every API request
Include "bot_id": "your_bot_id" in the request body.
View per-bot analytics
Filter traces, analytics, and billing by bot.
Example request with bot_id
{
"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
| Method | Path | Description |
|---|---|---|
| POST | /v1/respond | Primary decision endpoint |
| GET | /v1/status | System status & model registry |
| GET | /v1/models | Detailed model information |
| GET | /health | Health check |
| GET | /ready | Readiness 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
{
"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
| Field | Type | Description |
|---|---|---|
| company_id | string | Your company/tenant ID |
| bot_id | string | Bot identifier (from Dashboard → Bots) |
| session_id | string | Unique conversation session ID |
| workflow_id | string | Workflow type (e.g., support_triage) |
| current_user_message | string | The user's current message |
Optional Fields
| Field | Type | Description |
|---|---|---|
| current_structured_state | object | Pre-collected state (order ID, error code) |
| business_metadata | object | Business context (tier, region) |
| allowed_actions | array | Restrict to specific action IDs |
| prompt_id | string | Prompt ID to use for this request (from Dashboard → Prompts) |
| tool_mode | string | auto | force | none |
| memory_mode | string | auto | none |
| callback | object | Webhook delivery config |
Response Format
{
"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
| Field | Description |
|---|---|
| stage_prediction.stage_id | Current workflow stage |
| next_action.action_id | Selected next action |
| next_action.action_class | tool_call | clarification | escalation | handoff |
| verification.status | pass | warn | fail |
| escalation.should_escalate | Whether human handoff is needed |
| output_text | Response text to show the user |
| confidence | Combined confidence score (0-1) |
| trace_id | Unique ID for debugging & replay |
Workflow Stages (13)
greetingInitial contact, issue intakeidentity_collectionUser identity verificationaccount_verificationAccount identity verificationorder_lookupOrder details retrievalissue_clarificationIssue details gatheringerror_code_handlingError code lookup and guidancekb_troubleshootingKnowledge base troubleshootingfeedback_collectionUser feedback on resolutioncomplaint_eligibilityComplaint eligibility checkcomplaint_registrationFormal complaint registrationresolution_deliveryResolution delivery and confirmationescalationHuman handoffsession_closureSession wrap-upError Handling
Authentication Error
Missing or invalid API key
Not Found
Company profile not found
Validation Error
Invalid request body
Rate Limited
Too many requests
Server Error
Internal processing error
// 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
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_accountTurn 2 — User provides order ID
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_detailsTurn 3 — User wants escalation
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: trueWebhooks
Receive async notifications after each decision by including a callback object in your request.
{
"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
| Plan | Monthly Requests | Rate Limit |
|---|---|---|
| Free | 1,000 | 5 req/s |
| Starter | 50,000 | 20 req/s |
| Pro | 500,000 | 50 req/s |
| Enterprise | 10,000,000+ | Custom |
Usage headers are included in every response: X-Plan-Requests-Remaining, X-RateLimit-Remaining
SDKs & Libraries
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
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
Choose an agent category
Select what type of agent this prompt controls (e.g., Response Composer, Verifier).
Write your prompt content
Use {{placeholder_key}} syntax for dynamic values. Templates are provided for each category.
Add placeholders
Define keys, labels, default values, and whether they're required. Use the template library for common ones.
Assign to a bot (optional)
Link the prompt to a specific bot, or leave it shared. Tag requests with prompt_id in the API.
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.
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
| Key | Default | Description |
|---|---|---|
| {{company_name}} | Acme Corp | The customer's company name |
| {{user_name}} | John | The end user's display name |
| {{product_name}} | Widget Pro | The product being discussed |
| {{industry}} | Technology | The customer's industry vertical |
| {{tone}} | professional | Response tone (formal, casual, empathetic) |
| {{language}} | English | Response language |
| {{max_length}} | 256 | Maximum 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
The system gathers performance metrics from real API requests that use this prompt — success rate, verification pass rate, user satisfaction signals, and latency.
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.
Each variant is scored against your chosen metric. Scoring uses structural analysis, constraint quality, and historical performance patterns.
The best-performing variant is identified. It must beat the current prompt by at least the improvement threshold (default 2%) to qualify.
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
| Option | Default | Description |
|---|---|---|
| Strategy | OPRO | Which optimization algorithm to use |
| Evaluation Metric | Success Rate | success_rate | verification_pass | user_satisfaction | latency |
| Run Frequency | Daily | hourly | daily | weekly | manual |
| Auto-Promote | Off | Automatically promote winning variants to active |
| Improvement Threshold | 2% | Minimum improvement required to qualify as a winner |
| Max Variants Per Run | 5 | Number of candidate variants generated per optimization run |
| Min Sample Size | 50 | Minimum API requests before first optimization run |
Enabling Self-Improvement
Open the prompt detail panel
Click on any prompt from the Prompts page to view its details.
Expand 'Self-Improving Optimization'
Click the panel header to expand the optimization settings.
Toggle 'Enable Auto-Improvement'
This activates the optimization loop for this prompt.
Choose your strategy
Select OPRO, APE, DSPy Bootstrap, or PromptBreeder depending on your needs.
Set your metric and frequency
Choose what to optimize for and how often to run.
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.
{
"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
Lookup
System finds the prompt by ID and loads the active version.
Substitute
All {{placeholder}} values are replaced with prompt_overrides or defaults.
Inject
The resolved prompt is injected into the agent's system prompt for this request.
Track
The request is tagged with the prompt_id and version for analytics and optimization.
Python Example
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
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.
// 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:
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, promotedAtEdge 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
- Scan Traces — Click "Scan Traces" to analyze recent API traces for failures
- Auto-Detect — Engine identifies verification failures, missed escalations, hallucinations, etc.
- Classify — Issues are grouped into 12 categories with severity levels
- Fix Proposals — Engine suggests guardrails, prompt edits, or threshold changes
- 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.
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, resolvedByGuardrails
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
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[], statusWebhook 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
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
| Method | Path | Description |
|---|---|---|
| POST | /v1/connectors | Create 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}/activate | Activate |
| POST | .../{id}/deactivate | Deactivate |
| POST | .../{id}/test | Test endpoint |
| POST | /v1/connectors/generate-secret | Generate HMAC secret |
| GET | /v1/connectors/{company_id}/tools/available | List webhook tools |
7 authentication methods
10 subscribable event types
Connector Python SDK
Typed convenience methods for all connector operations. Sync and async variants included.
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
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 existConnectorAuthError(401/403)Invalid or missing API keyConnectorValidationError(422)Invalid connector configurationConnectorSDKError(5xx)Base class for all SDK errorsKnowledge 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
Add a source
Upload documents, connect APIs, or point to URLs. 15 source types supported.
Pick a blueprint
Choose from 12 retrieval blueprints (FAQ, Policy Lookup, Troubleshooting, etc.) or create custom.
Create a connection
A connection links a source to a blueprint with specific pipeline settings.
Query in playground
Test retrieval quality before going live. Tune chunking, reranking, and thresholds.
Built-in blueprints
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.
