Getting Started

Get started with the Dryade API. Find your API key, authenticate requests, and understand rate limits.

Last updated: 20 مارس 2026

Getting Started

This guide walks you through deploying Dryade, configuring your first model provider, installing a plugin, and creating your first AI agent.

Prerequisites

Before installing Dryade, ensure your environment meets these requirements:

  • Docker (v24.0+) and Docker Compose (v2.20+)
  • 4 GB RAM minimum (8 GB+ recommended for running local models)
  • 20 GB disk space for container images and plugin storage
  • Operating system: Linux (Ubuntu 22.04+, Debian 12+), macOS 13+, or Windows with WSL2
  • Ports: 3000 (UI), 8000 (API), 9471 (internal plugin manager) must be available

Verify Docker is installed and running:

docker --version
docker compose version

Quick Start

Clone the Dryade repository and start the platform:

git clone https://github.com/dryade-ai/dryade.git
cd dryade
cp .env.example .env
docker compose up -d

The first startup pulls container images and initializes the PostgreSQL database. This typically takes 2-3 minutes.

Once running, access the Dryade UI at http://localhost:3000. You will be guided through initial account creation on first access.

To verify all services are healthy:

docker compose ps

You should see core, db, pm (Plugin Manager), and web containers in a running state.

To stop the platform:

docker compose down

To stop and remove all data (database, plugin storage):

docker compose down -v

To view logs:

# All services
docker compose logs -f

# Core only
docker compose logs -f core

Environment Configuration

The .env file controls core platform settings. Key variables to review:

  • DRYADE_DB_PASSWORD — PostgreSQL password (change from the default before any production use)
  • DRYADE_SECRET_KEY — Application secret used for session signing (auto-generated if not set)
  • DRYADE_HOST — Bind address (default 0.0.0.0)
  • DRYADE_PORT — API port (default 8000)

See the Deployment guide for production configuration recommendations.

Configure Your First Model

Dryade routes agent inference to model providers you configure. Navigate to Settings > Models in the UI to add a provider.

Option A: OpenAI API

  1. Go to Settings > Models > Add Provider
  2. Select OpenAI from the provider list
  3. Enter your API key
  4. Select which models to enable (e.g., gpt-4o, gpt-4o-mini)
  5. Click Save

You can also configure the model provider via the API:

curl -X POST https://localhost:8000/v1/models/providers \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "openai",
    "api_key": "sk-...",
    "models": ["gpt-4o", "gpt-4o-mini"]
  }'

Option B: Local Model (vLLM or Ollama)

For air-gapped or on-premise deployments, configure a local model server:

  1. Go to Settings > Models > Add Provider
  2. Select OpenAI-Compatible (works with vLLM, Ollama, and other OpenAI API-compatible servers)
  3. Set the Base URL to your local model server (e.g., http://host.docker.internal:11434/v1 for Ollama)
  4. Leave the API key blank if your local server does not require authentication
  5. Manually enter the model name (e.g., llama3.1:70b)
  6. Click Save

Example with Ollama running on the host:

# Start Ollama on the host machine
ollama serve &
ollama pull llama3.1:70b

# Configure in Dryade (via API)
curl -X POST https://localhost:8000/v1/models/providers \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "openai-compatible",
    "base_url": "http://host.docker.internal:11434/v1",
    "models": ["llama3.1:70b"]
  }'

Install Your First Plugin

Plugins extend Dryade with new capabilities — RAG pipelines, code execution sandboxes, monitoring dashboards, and more. Starter tier includes access to the core plugin catalog.

Via the UI

  1. Navigate to Marketplace in the sidebar
  2. Browse the plugin catalog or use the search and filter controls
  3. Click on a plugin to view its details, permissions, and tier requirements
  4. Click Install
  5. The Plugin Manager verifies the plugin’s cryptographic signatures and hash integrity before installation

Via the API

import requests

headers = {
    "Authorization": "Bearer YOUR_API_KEY"
}

# List available plugins
catalog = requests.get(
    "https://localhost:8000/v1/plugins/catalog",
    headers=headers
).json()

# Install a plugin by ID
response = requests.post(
    "https://localhost:8000/v1/plugins/install",
    headers=headers,
    json={"plugin_id": "dryade-rag-pipeline"}
)

print(response.json())

Installed plugins appear in My Plugins and are immediately available to agents.

Security note: Every plugin installation goes through Dryade’s signed allowlist verification. The Plugin Manager checks the plugin’s Ed25519 signature, marketplace counter-signature, and SHA-256 source hash before any plugin code is loaded. See the Security docs for the full plugin security model.

Create Your First Agent

Agents are the core unit of work in Dryade. Each agent combines a model, a set of tools (provided by plugins), and a system prompt that defines its behavior.

Via the Factory UI

The Factory is Dryade’s visual agent builder. It lets you configure agents without writing code and test them immediately in an integrated chat interface.

  1. Navigate to Factory in the sidebar
  2. Click New Agent
  3. Configure the agent:
    • Name: Give the agent a descriptive name (e.g., “Code Review Assistant”)
    • Model: Select from your configured providers
    • System prompt: Define the agent’s role and instructions
    • Tools: Select which plugin-provided tools the agent can use
  4. Click Create
  5. Test the agent in the built-in chat interface

Via the API

import requests

headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
}

# Create an agent
agent = requests.post(
    "https://localhost:8000/v1/agents",
    headers=headers,
    json={
        "name": "Code Review Assistant",
        "model": "gpt-4o",
        "system_prompt": "You are a senior software engineer. Review code for bugs, security issues, and style.",
        "tools": ["code-analysis", "file-reader"]
    }
).json()

agent_id = agent["id"]

# Send a message to the agent
response = requests.post(
    f"https://localhost:8000/v1/agents/{agent_id}/messages",
    headers=headers,
    json={
        "content": "Review this Python function for security issues:\n\ndef query(user_input):\n    return db.execute(f'SELECT * FROM users WHERE name = {user_input}')"
    }
)

print(response.json()["content"])
const headers = {
  "Authorization": "Bearer YOUR_API_KEY",
  "Content-Type": "application/json"
};

// Create an agent
const agentRes = await fetch("https://localhost:8000/v1/agents", {
  method: "POST",
  headers,
  body: JSON.stringify({
    name: "Code Review Assistant",
    model: "gpt-4o",
    system_prompt: "You are a senior software engineer. Review code for bugs, security issues, and style.",
    tools: ["code-analysis", "file-reader"]
  })
});

const agent = await agentRes.json();

// Send a message
const msgRes = await fetch(`https://localhost:8000/v1/agents/${agent.id}/messages`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    content: "Review this function for security issues..."
  })
});

const result = await msgRes.json();
console.log(result.content);

API Authentication

Your API key is available in your account settings. Navigate to Settings > Subscription to view and manage your API keys.

Base URL: https://api.dryade.ai/v1 (cloud) or https://localhost:8000/v1 (self-hosted)

Include your API key in the Authorization header with all requests:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.dryade.ai/v1/plugins
import requests

headers = {
    "Authorization": "Bearer YOUR_API_KEY"
}

response = requests.get("https://api.dryade.ai/v1/plugins", headers=headers)
data = response.json()
const response = await fetch("https://api.dryade.ai/v1/plugins", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY"
  }
});

const data = await response.json();

API keys are scoped to individual users and inherit role-based permissions. Keys can be rotated at any time from the settings page — see the Security docs for details on key storage and rotation.

Rate Limits

API rate limits depend on your subscription tier:

TierRequests per minute
Starter60
Team300
Enterprise1,000

Rate limit headers are included in every API response:

  • X-RateLimit-Limit — Maximum requests per minute for your tier
  • X-RateLimit-Remaining — Requests remaining in the current window
  • X-RateLimit-Reset — Unix timestamp when the window resets

Enterprise customers can request custom rate limits. Contact your account representative or see the Subscriptions API for details.

When the limit is exceeded, the API returns HTTP 429. Implement exponential backoff in your client:

import time
import requests

def api_request(url, headers, max_retries=3):
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)
        if response.status_code == 429:
            reset_time = int(response.headers.get("X-RateLimit-Reset", 0))
            wait = max(reset_time - time.time(), 2 ** attempt)
            time.sleep(wait)
            continue
        return response
    raise Exception("Rate limit exceeded after retries")

Troubleshooting

Containers fail to start: Ensure Docker has at least 4 GB of memory allocated. On Docker Desktop (macOS/Windows), check Settings > Resources > Memory.

Cannot connect to localhost:3000: Verify no other service is using port 3000. You can change the UI port in .env with DRYADE_WEB_PORT.

Plugin installation fails: Check that the Plugin Manager container (pm) is running with docker compose ps. Plugin installation requires a valid signed allowlist — see docker compose logs pm for signature verification errors.

Model provider connection errors: For local models (Ollama/vLLM), ensure the model server is reachable from inside the Docker network. Use host.docker.internal instead of localhost when the model server runs on the host machine.

For additional help, see the Errors reference or contact support.

Next Steps

Now that you have Dryade running with a model provider and your first plugin installed, explore these guides:

  • Plugin Development — Build and publish your own plugins for the Dryade marketplace
  • Workflows — Chain agents into multi-step automation workflows
  • Deployment — Production deployment with Kubernetes, air-gapped installation, and scaling
  • Security — Deep dive into the signed allowlist model, post-quantum cryptography, and compliance
  • API Reference — Complete API documentation for all endpoints
  • Webhooks — Subscribe to platform events for external integrations
  • SDKs — Python and JavaScript client libraries