Robyn

https://robyn.tech/documentation
Admin
Robyn is a fast, asynchronous Python web framework powered by Rust, providing robust features for...
Tokens:52,052
Snippets:601
Trust Score:6.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Full GraphQL application example

Source: https://robyn.tech/documentation/en/api_reference/graphql-support

A complete example showing the setup of a Robyn app with a GraphQL schema and endpoints.

```python
from typing import List, Optional
from robyn import Robyn, jsonify
import json

import dataclasses
import strawberry
import strawberry.utils.graphiql


@strawberry.type
class User:
  name: str


@strawberry.type
class Query:
  @strawberry.field
  def user(self) -> Optional[User]:
      return User(name="Hello")


schema = strawberry.Schema(Query)

app = Robyn(__file__)


@app.get("/", const=True)
async def get():
  return strawberry.utils.graphiql.get_graphiql_html()


@app.post("/")
async def post(request):
  body = request.json()
  query = body["query"]
  variables = body.get("variables", None)
  context_value = {"request": request}
  root_value = body.get("root_value", None)
  operation_name = body.get("operation_name", None)

  data = await schema.execute(
      query,
      variables,
      context_value,
      root_value,
      operation_name,
  )

  return jsonify(
      {
          "data": (data.data),
          **({"errors": data.errors} if data.errors else {}),
          **({"extensions": data.extensions} if data.extensions else {}),
      }
  )


if __name__ == "__main__":
  app.start(port=8080, host="0.0.0.0")
```

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

### Install and run a minimal Robyn app

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Initializes a basic Robyn application and starts the server on a specified host and port.

```python
# pip install robyn
from robyn import Robyn

app = Robyn(__file__)

@app.get("/")
def index():
    return "Hello, world"

app.start(host="0.0.0.0", port=8080)  # host defaults to 127.0.0.1
```

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

### Install dependencies

Source: https://robyn.tech/documentation/en/api_reference/graphql-support

Install Robyn and strawberry-graphql via pip.

```bash
pip install robyn strawberry-graphql
```

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

### Migration: Previous Version Behavior

Source: https://robyn.tech/documentation/en/api_reference/timeout_configuration

Example of how applications were started in older versions without explicit timeouts.

```python
# Previously: no timeout (could cause resource exhaustion)
app.start(host="0.0.0.0", port=8080)
```

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

### Install Robyn via pip

Source: https://robyn.tech/documentation/en/example_app

Commands to set up a virtual environment and install the Robyn package.

```bash
$ python3 -m venv venv
$ source venv/bin/activate
$ pip install robyn
```

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

### Install System Monitoring Dependencies

Source: https://robyn.tech/documentation/en/api_reference/agents

Optional dependency installation for enhanced system monitoring capabilities.

```bash
pip install psutil  # Enhanced system monitoring
```

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

### Install Robyn with templating extension

Source: https://robyn.tech/documentation/en/api_reference

Install the templating extension for Robyn using pip.

```bash
pip install "robyn[templating]"
```

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

### Install Robyn

Source: https://robyn.tech/documentation/en/api_reference/ai

Install the Robyn package to access AI features.

```bash
pip install robyn
```

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

### GET /hello

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Renders a Jinja2 template.

```APIDOC
## GET /hello

### Description
Returns a rendered Jinja2 template.

### Method
GET

### Endpoint
/hello
```

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

### GET /hello_world

Source: https://robyn.tech/documentation/en/api_reference/const_requests

Demonstrates how to define a route with the const=True parameter to pre-compute the response.

```APIDOC
## GET /

### Description
Pre-computes the response for the route to improve response time by bypassing the router.

### Method
GET

### Endpoint
/

### Request Example
```python
@app.get("/", const=True)
async def h():
    return "Hello, world"
```
```

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

### Start the Robyn server

Source: https://robyn.tech/documentation/en/architecture

Initializes the server, checks for port availability, and triggers the process management logic.

```python
    def start(self, host: str = "127.0.0.1", port: int = 8080, _check_port: bool = True):
        """
        Starts the server

        :param host str: represents the host at which the server is listening
        :param port int: represents the port number at which the server is listening
        :param _check_port bool: represents if the port should be checked if it is already in use
        """

        host = os.getenv("ROBYN_HOST", host)
        port = int(os.getenv("ROBYN_PORT", port))
        open_browser = bool(os.getenv("ROBYN_BROWSER_OPEN", self.config.open_browser))

        if _check_port:
            while self.is_port_in_use(port):
                logger.error("Port %s is already in use. Please use a different port.", port)
                try:
                    port = int(input("Enter a different port: "))
                except Exception:
                    logger.error("Invalid port number. Please enter a valid port number.")
                    continue

        logger.info("Robyn version: %s", __version__)
        logger.info("Starting server at http://%s:%s", host, port)

        mp.allow_connection_pickling()

        run_processes(
            host,
            port,
            self.directories,
            self.request_headers,
            self.router.get_routes(),
            self.middleware_router.get_global_middlewares(),
            self.middleware_router.get_route_middlewares(),
            self.web_socket_router.get_routes(),
            self.event_handlers,
            self.config.workers,
            self.config.processes,
            self.response_headers,
            open_browser,
        )
```

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

### Initialize MCP in a Robyn Application

Source: https://robyn.tech/documentation/en/api_reference/mcps

Basic setup demonstrating the registration of a resource, tool, and prompt within a Robyn application.

```python
from robyn import Robyn

app = Robyn(__file__)

@app.mcp.resource("echo://{message}")
def echo_resource(message: str) -> str:
    return f"Resource echo: {message}"

@app.mcp.tool()
def echo_tool(message: str) -> str:
    return f"Tool echo: {message}"

@app.mcp.prompt()
def echo_prompt(message: str) -> str:
    return f"Please process: {message}"

app.start()
```

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

### Sample robyn.env Configuration

Source: https://robyn.tech/documentation/en/api_reference/robyn_env

An example of a robyn.env file containing common server configuration variables.

```text
ROBYN_PORT=8080
ROBYN_HOST=127.0.0.1
RANDOM_ENV=123
ROBYN_BROWSER_OPEN=True
ROBYN_DEV_MODE=True
ROBYN_MAX_PAYLOAD_SIZE=1000000
```

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

### Initialize Robyn Server in Rust

Source: https://robyn.tech/documentation/en/architecture

The start method configures the event loop and prepares routers for the Robyn server instance.

```rust
    pub fn start(
        &mut self,
        py: Python,
        socket: &PyCell<SocketHeld>,
        workers: usize,
    ) -> PyResult<()> {
        pyo3_log::init();

        if STARTED
            .compare_exchange(false, true, SeqCst, Relaxed)
            .is_err()
        {
            debug!("Robyn is already running...");
            return Ok(());
        }

        let raw_socket = socket.try_borrow_mut()?.get_socket();

        let router = self.router.clone();
        let const_router = self.const_router.clone();
        let middleware_router = self.middleware_router.clone();
        let web_socket_router = self.websocket_router.clone();
        let global_request_headers = self.global_request_headers.clone();
        let global_response_headers = self.global_response_headers.clone();
        let directories = self.directories.clone();

        let asyncio = py.import("asyncio")?;
        let event_loop = asyncio.call_method0("new_event_loop")?;
        asyncio.call_method1("set_event_loop", (event_loop,))?;

        let startup_handler = self.startup_handler.clone();
        let shutdown_handler = self.shutdown_handler.clone();
```

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

### GET /events

Source: https://robyn.tech/documentation/en/api_reference/server_sent_events

An example of creating an SSE stream using a regular generator to push events to the client.

```APIDOC
## GET /events

### Description
Streams a series of events from the server to the client using a generator.

### Method
GET

### Endpoint
/events

### Response
#### Success Response (200)
- **Content-Type** (string) - text/event-stream
- **Body** (stream) - A stream of SSEMessage objects.
```

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

### GET /legacy

Source: https://robyn.tech/documentation/en/api_reference/openapi

An example of a deprecated endpoint.

```APIDOC
## GET /legacy

### Description
An old endpoint kept for backwards compatibility, marked as deprecated.

### Method
GET

### Endpoint
/legacy
```

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

### Define GET route for GraphiQL

Source: https://robyn.tech/documentation/en/api_reference/graphql-support

Serve the GraphiQL IDE using a GET request.

```python
  @app.get("/", const=True)
  async def get():
  return strawberry.utils.graphiql.get_graphiql_html()
```

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

### Install Robyn with Pydantic support

Source: https://robyn.tech/documentation/en/api_reference/pydantic

Use the optional extra to install Robyn with Pydantic dependencies.

```bash
pip install "robyn[pydantic]"
```

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

### Development Setup

Source: https://robyn.tech/documentation/en/api_reference/timeout_configuration

Use extended timeout values to facilitate easier debugging and testing.

```python
# Development-friendly settings
app.start(
    client_timeout=300,     # Long timeout for debugging
    keep_alive_timeout=60   # Longer keep-alive for testing
)
```

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

### GET /hello_world

Source: https://robyn.tech/documentation/en/api_reference/exceptions

Demonstrates how to register a custom exception handler using the @app.exception decorator to catch exceptions and return a custom response.

```APIDOC
## GET /hello_world

### Description
Registers a custom exception handler to intercept exceptions and return a 500 status code with a custom error message.

### Method
GET

### Endpoint
/hello_world

### Request Example
@app.exception
def handle_exception(error: Exception):
    return Response(status_code=500, description=f"error msg: {error}", headers={})
```

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

### Migration: Current Version Behavior

Source: https://robyn.tech/documentation/en/api_reference/timeout_configuration

Example showing the current default timeout behavior compared to explicit configuration.

```python
# Now: automatic 30s client timeout, 20s keep-alive
app.start(host="0.0.0.0", port=8080)
# Equivalent to:
app.start(
    host="0.0.0.0", 
    port=8080,
    client_timeout=30,
    keep_alive_timeout=20
)
```

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

### Example HTML template file

Source: https://robyn.tech/documentation/en/api_reference/templating

A sample HTML file structure using Jinja2 syntax for variable injection.

```html
  <!DOCTYPE html>
  <html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Results</title>
  </head>

  <body>
   Hello {{ framework }}! You're using {{ templating_engine }}.
  </body>
```

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

### GET /page

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Serves an HTML file.

```APIDOC
## GET /page

### Description
Serves an HTML file from the server filesystem.

### Method
GET

### Endpoint
/page
```

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

### Deploying the application with process and worker flags

Source: https://robyn.tech/documentation/en/example_app/deployment

Use this command to specify the number of processes and workers when starting the application in a production environment.

```bash
python app.py --processes=n --workers=m
```

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

### GET /download

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Serves a file as an attachment.

```APIDOC
## GET /download

### Description
Serves a file from the server filesystem as an attachment.

### Method
GET

### Endpoint
/download
```

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

### Implement a User Management API

Source: https://robyn.tech/documentation/en/api_reference/getting_started

A comprehensive example showing sync and async handlers, path parameters, query parameters, and JSON request body parsing.

```python
from robyn import Robyn, Request
import asyncio
import json
import time
from typing import Dict, Any

app = Robyn(__file__)

# In-memory storage for demo (use a real database in production)
users: Dict[str, Dict[str, Any]] = {
    "1": {"id": "1", "name": "Alice", "email": "alice@example.com", "created_at": "2024-01-01"},
    "2": {"id": "2", "name": "Bob", "email": "bob@example.com", "created_at": "2024-01-02"}
}

# Const route for health checks (cached in Rust for max performance)
@app.get("/health", const=True)
def health_check():
    return {"status": "healthy", "version": "1.0.0"}

# Async handler for database-like operations
@app.get("/users/:id")
async def get_user(path_params):
    user_id = path_params["id"]
    
    # Simulate async database lookup
    await asyncio.sleep(0.01)  # Simulate DB query time
    
    if user_id in users:
        return {"success": True, "user": users[user_id]}
    else:
        return {"success": False, "error": "User not found"}, 404

# Get all users with pagination
@app.get("/users")
async def list_users(query_params):
    page = int(query_params.get("page", "1"))
    limit = int(query_params.get("limit", "10"))
    
    # Simulate async operation
    await asyncio.sleep(0.01)
    
    user_list = list(users.values())
    start = (page - 1) * limit
    end = start + limit
    
    return {
        "users": user_list[start:end],
        "total": len(user_list),
        "page": page,
        "limit": limit
    }

# Create new user
@app.post("/users")
async def create_user(body):
    try:
        data = json.loads(body)
        
        # Validate required fields
        if not data.get("name") or not data.get("email"):
            return {"success": False, "error": "Name and email are required"}, 400
        
        # Generate new ID
        new_id = str(len(users) + 1)
        new_user = {
            "id": new_id,
            "name": data["name"],
            "email": data["email"],
            "created_at": time.strftime("%Y-%m-%d")
        }
        
        # Simulate async database save
        await asyncio.sleep(0.02)
        users[new_id] = new_user
        
        return {"success": True, "user": new_user}, 201
        
    except json.JSONDecodeError:
        return {"success": False, "error": "Invalid JSON"}, 400

# Sync handler for CPU-intensive operations
@app.post("/calculate")
def calculate_fibonacci(body):
    try:
        data = json.loads(body)
        n = data.get("number", 10)
        
        if n < 0 or n > 35:  # Prevent excessive computation
            return {"error": "Number must be between 0 and 35"}, 400
        
        # CPU-intensive calculation (runs in thread pool)
        def fib(x):
            if x <= 1:
                return x
            return fib(x-1) + fib(x-2)
        
        start_time = time.time()
        result = fib(n)
        calc_time = time.time() - start_time
        
        return {
            "input": n,
            "result": result,
            "calculation_time": f"{calc_time:.4f}s"
        }
        
    except json.JSONDecodeError:
        return {"error": "Invalid JSON"}, 400

if __name__ == "__main__":
    app.start(port=8080)
```

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

### Robyn CLI interactive output

Source: https://robyn.tech/documentation/en/example_app

Example of the interactive prompts displayed when running the Robyn creation command.

```bash
$ python3 -m robyn --create
? Directory Path: .
? Need Docker? (Y/N) Y
? Please select project type (Mongo/Postgres/Sqlalchemy/Prisma):
❯ No DB
  Sqlite
  Postgres
  MongoDB
  SqlAlchemy
  Prisma
```

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

### Install OpenAI Package

Source: https://robyn.tech/documentation/en/api_reference/ai

Use this command to resolve ImportError for the openai library.

```bash
pip install openai
```

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

### High-Traffic Production Setup

Source: https://robyn.tech/documentation/en/api_reference/timeout_configuration

Optimize timeout settings for high-traffic scenarios by adjusting client and keep-alive durations.

```python
# Optimized for high-traffic scenarios
app.start(
    host="0.0.0.0",
    port=8080,
    client_timeout=60,      # Allow longer processing time
    keep_alive_timeout=15   # Shorter keep-alive for faster turnover
)
```

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

### Example Access Log Output

Source: https://robyn.tech/documentation/en/example_app/monitoring_and_logging

The format of the log line generated by the access logger.

```text
INFO:robyn.access:GET /crimes -> 200 (1.83ms)
```

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

### Handle Lifecycle Events

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Register startup and shutdown handlers to execute code when the application starts or stops.

```python
@app.startup_handler
async def on_startup():
    print("starting up")

@app.shutdown_handler
def on_shutdown():
    print("shutting down")
```

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

### Environment Variable Configuration

Source: https://robyn.tech/documentation/en/api_reference/scaling

Set these environment variables to configure production settings and application parameters before starting the application.

```bash
# Production environment variables
export ROBYN_HOST=0.0.0.0
export ROBYN_PORT=8080
export ROBYN_LOG_LEVEL=INFO
export ROBYN_PROCESSES=4
export ROBYN_WORKERS=2

# Database configuration
export DATABASE_URL=postgresql://user:pass@localhost/db
export REDIS_URL=redis://localhost:6379/0

# Application settings
export SECRET_KEY=your-secret-key
export DEBUG=false
export ENVIRONMENT=production

# Start application with environment config
python app.py
```

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

### Implement Rate Limiting with robyn-rate-limits

Source: https://robyn.tech/documentation/en/plugins

Uses the InMemoryStore to enforce a limit of 3 requests per 100 seconds. Requires the robyn-rate-limits package installed via pip.

```python
from robyn import Robyn, Request
from robyn_rate_limits import InMemoryStore
from robyn_rate_limits import RateLimiter

app = Robyn(__file__)
limiter = RateLimiter(store=InMemoryStore, calls_limit=3, limit_ttl=100)

@app.before_request()
def middleware(request: Request):
    return limiter.handle_request(app, request)

@app.get("/")
def h():
    return "Hello, World!"

app.start(port=8080)
```

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

### Initialize Robyn app

Source: https://robyn.tech/documentation/en/api_reference/graphql-support

Create the Robyn application instance.

```python
app = Robyn(__file__)
```

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

### Implement Request Access Logging

Source: https://robyn.tech/documentation/en/example_app/monitoring_and_logging

Uses a ContextVar to track request start time and middleware hooks to log method, path, status code, and duration.

```python
import logging
import time
from contextvars import ContextVar

from robyn import Request, Response

# A dedicated logger for access logs. It inherits Robyn's logging configuration,
# so keep the level at INFO or below (running with `--log-level WARN` would hide
# these lines).
logging.basicConfig(level=logging.INFO)
access_logger = logging.getLogger("robyn.access")

_request_start: ContextVar[float] = ContextVar("request_start")


@app.before_request()
def start_timer(request: Request):
    _request_start.set(time.perf_counter())
    return request


@app.after_request()
def log_request(request: Request, response: Response):
    start = _request_start.get(None)
    duration_ms = (time.perf_counter() - start) * 1000 if start is not None else 0.0
    access_logger.info(
        "%s %s -> %s (%.2fms)",
        request.method,
        request.url.path,
        response.status_code,
        duration_ms,
    )
    return response
```

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

### Serve Directories with Robyn

Source: https://robyn.tech/documentation/en/api_reference/static-files

Demonstrates serving directories in SPA mode, browsable listing mode, and direct file mode using app.serve_directory().

```python
import os
from robyn import Robyn

app = Robyn(__file__)

# Mode 1: SPA / Build folder (e.g., React, Vue)
app.serve_directory(
    route="/",
    directory_path=os.path.join(os.path.dirname(__file__), "build"),
    index_file="index.html",
)

# Mode 2: Browsable file listing
app.serve_directory(
    route="/files",
    directory_path="./uploads",
    show_files_listing=True,
)

# Mode 3: Direct file serving (no listing, no index)
app.serve_directory(
    route="/assets",
    directory_path="./static",
)

app.start(port=8080)
```

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

### Configure Basic Robyn App with OpenAPI

Source: https://robyn.tech/documentation/en/api_reference/openapi

Initialize a Robyn application with custom OpenAPI metadata and define routes using query and path parameters.

```python
from robyn.robyn import QueryParams

from robyn import Robyn, Request

app = Robyn(
    file_object=__file__,
    openapi=OpenAPI(
        info=OpenAPIInfo(
            title="Sample App",
            description="This is a sample server application.",
            termsOfService="https://example.com/terms/",
            version="1.0.0",
            contact=Contact(
                name="API Support",
                url="https://www.example.com/support",
                email="support@example.com",
            ),
            license=License(
                name="BSD2.0",
                url="https://opensource.org/license/bsd-2-clause",
            ),
            externalDocs=ExternalDocumentation(description="Find more info here", url="https://example.com/"),
            components=Components(),
        ),
    ),
)


@app.get("/")
async def welcome():
    """welcome endpoint"""
    return "hi"


class GetRequestParams(QueryParams):
    appointment_id: str
    year: int


@app.get("/api/v1/name", openapi_name="Name Route", openapi_tags=["Name"])
async def get(r: Request, query_params: GetRequestParams):
    """Get Name by ID"""
    return r.query_params


@app.delete("/users/:name", openapi_tags=["Name"])
async def delete(r: Request):
    """Delete Name by ID"""
    return r.path_params


if __name__ == "__main__":
    app.start()
```

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

### Create index.html

Source: https://robyn.tech/documentation/en/hosting

Sample HTML file to be served by the Robyn application.

```html
<h1> Hello World, this is Robyn framework! <h1>
```

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

### Production Mode Configurations

Source: https://robyn.tech/documentation/en/api_reference/getting_started

Run the application with optimized settings for performance and scaling.

```bash
# Fast mode (automatic optimization)
python app.py --fast

# Custom scaling configuration
python app.py --processes 4 --workers 2

# Production with specific log level
python app.py --fast --log-level INFO
```

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

### Create a virtual environment

Source: https://robyn.tech/documentation/en/api_reference/graphql-support

Initialize a new Python virtual environment.

```bash
python3 -m venv venv
```

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

### Scaling Configuration Guidelines

Source: https://robyn.tech/documentation/en/api_reference/scaling

Recommended process and worker ratios for CPU-intensive, I/O-intensive, and balanced workloads.

```bash
# For CPU-intensive applications
# Rule: processes = CPU cores, workers = 1
# Example: 8-core machine
python app.py --processes 8 --workers 1

# For I/O-intensive applications  
# Rule: processes = CPU cores / 2, workers = 2-4
# Example: 8-core machine
python app.py --processes 4 --workers 3

# For balanced applications
# Rule: processes = CPU cores / 2, workers = 2
# Example: 8-core machine
python app.py --processes 4 --workers 2

# Memory considerations
# Each process uses ~50-100MB base memory
# Monitor with: ps aux | grep python
```

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

### GET /users

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Lists users with OpenAPI documentation.

```APIDOC
## GET /users

### Description
Returns a list of users. This endpoint is documented in the OpenAPI spec.

### Method
GET

### Endpoint
/users
```

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

### GET /health

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Returns health status with caching.

```APIDOC
## GET /health

### Description
Returns the health status of the application. This route is cached in Rust.

### Method
GET

### Endpoint
/health
```

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

### GET /sse

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Streams server-sent events to the client.

```APIDOC
## GET /sse

### Description
Streams server-sent events to the client using SSEResponse.

### Method
GET

### Endpoint
/sse
```

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

### GET /data

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Returns data using injected dependencies.

```APIDOC
## GET /data

### Description
Returns data retrieved via global and router-level dependency injection.

### Method
GET

### Endpoint
/data
```

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

### Initialize a new Robyn project

Source: https://robyn.tech/documentation/en/example_app

Command to trigger the interactive CLI tool for creating a new Robyn application.

```bash
$ python -m robyn --create
```

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

### GET /users/:id

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Retrieves a user by ID with validation.

```APIDOC
## GET /users/:id

### Description
Retrieves user information. Returns a 400 error if the ID is not numeric.

### Method
GET

### Endpoint
/users/:id

### Parameters
#### Path Parameters
- **id** (string) - Required - The numeric user ID
```

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

### GET /stream

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Streams raw data chunks to the client.

```APIDOC
## GET /stream

### Description
Streams binary data chunks to the client with a specified media type.

### Method
GET

### Endpoint
/stream
```

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

### client.get(path, **kw)

Source: https://robyn.tech/documentation/en/api_reference/testing

Performs a GET request to the specified path.

```APIDOC
## GET [path]

### Description
Performs a GET request to the specified path.

### Parameters
#### Path Parameters
- **path** (str) - Required - The endpoint path to request.

#### Keyword Arguments
- **body** (str | bytes) - Optional - Raw request body
- **headers** (dict) - Optional - Request headers
- **query_params** (dict) - Optional - Query string parameters
- **form_data** (dict) - Optional - Form data fields
- **files** (dict) - Optional - File uploads (name → bytes)
```

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

### GET /

Source: https://robyn.tech/documentation/en/api_reference/advanced_features

Retrieves the client's IP address from the request object.

```APIDOC
## GET /

### Description
Returns a greeting message including the client's IP address.

### Method
GET

### Endpoint
/

### Response
#### Success Response (200)
- **body** (string) - A greeting string containing the client's IP address.
```

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

### Combine Static Files with API Routes

Source: https://robyn.tech/documentation/en/api_reference/static-files

Shows how to serve a frontend SPA alongside backend API routes in a single Robyn application.

```python
import os
from robyn import Robyn, Request

app = Robyn(__file__)

# Serve the React/Vue build
app.serve_directory(
    route="/",
    directory_path=os.path.join(os.path.dirname(__file__), "frontend/build"),
    index_file="index.html",
)

# API routes work alongside static serving
@app.get("/api/health")
def health():
    return {"status": "ok"}

@app.get("/api/users")
async def get_users(request: Request):
    return [{"id": 1, "name": "Alice"}]

app.start(port=8080)
```

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

### GET /model

Source: https://robyn.tech/documentation/en/api_reference/response-objects

Returns a Pydantic BaseModel instance, which is automatically serialized to JSON.

```APIDOC
## GET /model

### Description
Returns a JSON response serialized from a Pydantic model.

### Method
GET

### Endpoint
/model

### Response
#### Success Response (200)
- **body** (JSON) - Serialized Pydantic model
```

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

### Define and Test a Robyn Application

Source: https://robyn.tech/documentation/en/api_reference/testing

Demonstrates setting up a Robyn app with various routes and testing them using the TestClient.

```python
import pytest
from robyn import Robyn
from robyn.testing import TestClient

app = Robyn(__file__)

@app.get("/")
def index(request):
    return "Home"

@app.get("/health")
def health(request):
    return {"status": "ok"}

@app.post("/echo")
def echo(request):
    return request.json()

client = TestClient(app)

def test_index():
    assert client.get("/").text == "Home"

def test_health():
    data = client.get("/health").json()
    assert data["status"] == "ok"

def test_echo():
    payload = {"message": "hello"}
    response = client.post("/echo", json_data=payload)
    assert response.json() == payload

def test_not_found():
    response = client.get("/nonexistent")
    assert response.status_code == 404
```

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

### GET /binary

Source: https://robyn.tech/documentation/en/api_reference/response-objects

Returns a bytes object with Content-Type application/octet-stream and status 200.

```APIDOC
## GET /binary

### Description
Returns binary data with a 200 status code.

### Method
GET

### Endpoint
/binary

### Response
#### Success Response (200)
- **body** (bytes) - Binary data content
```

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

### Initialize Simple AI Agent with OpenAI

Source: https://robyn.tech/documentation/en/api_reference/ai

Configures an agent using the simple runner and an OpenAI API key.

```python
from robyn.ai import agent

# Create simple agent with OpenAI
from robyn.ai import configure

config = configure(openai_api_key="your-openai-key")
simple_agent = agent(runner="simple", config=config)

# Use the agent
result = await simple_agent.run("What's the weather like?")
# Returns structured response with AI-generated content
```

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

### GET /events/database

Source: https://robyn.tech/documentation/en/api_reference/server_sent_events

Streams database events using an async generator and SSEResponse.

```APIDOC
## GET /events/database

### Description
Streams database events to the client using an async generator. Each event is sent as an SSE message with a specific event type and ID.

### Method
GET

### Endpoint
/events/database
```

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

### Configure Timeouts in app.start()

Source: https://robyn.tech/documentation/en/api_reference/timeout_configuration

Set client and keep-alive timeouts directly within the application startup method.

```python
from robyn import Robyn

app = Robyn(__file__)

@app.get("/")
async def hello(request):
    return "Hello, world!"

# Configure timeout settings
app.start(
    host="0.0.0.0", 
    port=8080,
    client_timeout=30,          # Client connection timeout (seconds)
    keep_alive_timeout=20       # Keep-alive timeout (seconds)
)
```

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

### GET /search

Source: https://robyn.tech/documentation/en/api_reference/request_object

Performs a search using query parameters with support for optional types.

```APIDOC
## GET /search

### Description
Performs a search operation using query parameters. Supports optional parameters which resolve to null if not provided.

### Method
GET

### Endpoint
/search

### Parameters
#### Query Parameters
- **name** (string) - Required - The name to search for.
- **age** (int) - Optional - The age filter, defaults to null.
```

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

### GET /export

Source: https://robyn.tech/documentation/en/api_reference/server_sent_events

Streams database records as a CSV file using an async generator and StreamingResponse.

```APIDOC
## GET /export

### Description
Streams database records as a CSV file. It uses an async generator to fetch data from the database asynchronously and yields chunks of data.

### Method
GET

### Endpoint
/export
```

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

### GET /download

Source: https://robyn.tech/documentation/en/api_reference/server_sent_events

Streams a large file as binary data using a sync generator and StreamingResponse.

```APIDOC
## GET /download

### Description
Streams a large file in chunks to the client as an application/octet-stream, preventing the entire file from being loaded into memory.

### Method
GET

### Endpoint
/download
```

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

### Implement a RESTful API with Robyn

Source: https://robyn.tech/documentation/en/api_reference/getting_started

Demonstrates handling standard HTTP methods for a blog post resource. Requires the Robyn framework and Request object.

```python
from robyn import Robyn, Request

app = Robyn(__file__)

# In-memory storage for demo
posts = {
    "1": {"id": "1", "title": "First Post", "content": "Hello World"},
    "2": {"id": "2", "title": "Second Post", "content": "Learning Robyn"}
}

# GET - Retrieve all posts
@app.get("/posts")
def get_posts(query_params):
    limit = int(query_params.get("limit", "10"))
    posts_list = list(posts.values())[:limit]
    return {"posts": posts_list, "total": len(posts)}

# GET - Retrieve specific post
@app.get("/posts/:id")
def get_post(path_params):
    post_id = path_params["id"]
    if post_id in posts:
        return {"post": posts[post_id]}
    return {"error": "Post not found"}, 404

# POST - Create new post
@app.post("/posts")
def create_post(request: Request):
    data = request.json()
    post_id = str(len(posts) + 1)
    new_post = {
        "id": post_id,
        "title": data.get("title", ""),
        "content": data.get("content", "")
    }
    posts[post_id] = new_post
    return {"message": "Post created", "post": new_post}, 201

# PUT - Update entire post
@app.put("/posts/:id")
def update_post(request: Request, path_params):
    post_id = path_params["id"]
    if post_id not in posts:
        return {"error": "Post not found"}, 404
    
    data = request.json()
    posts[post_id] = {
        "id": post_id,
        "title": data.get("title", ""),
        "content": data.get("content", "")
    }
    return {"message": "Post updated", "post": posts[post_id]}

# PATCH - Partial update
@app.patch("/posts/:id")
def patch_post(request: Request, path_params):
    post_id = path_params["id"]
    if post_id not in posts:
        return {"error": "Post not found"}, 404
    
    data = request.json()
    post = posts[post_id]
    
    # Update only provided fields
    if "title" in data:
        post["title"] = data["title"]
    if "content" in data:
        post["content"] = data["content"]
    
    return {"message": "Post updated", "post": post}

# DELETE - Remove post
@app.delete("/posts/:id")
def delete_post(path_params):
    post_id = path_params["id"]
    if post_id not in posts:
        return {"error": "Post not found"}, 404
    
    deleted_post = posts.pop(post_id)
    return {"message": "Post deleted", "post": deleted_post}
```

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

### Create a Rust file via CLI

Source: https://robyn.tech/documentation/en/api_reference/using_rust_directly

Use the Robyn CLI to generate a new Rust file for your project.

```bash
python -m robyn --create-rust-file hello_world
```

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

### TestClient.get(path, ...)

Source: https://robyn.tech/documentation/en/api_reference/testing

Performs a GET request to the specified path using the in-process TestClient.

```APIDOC
## GET [path]

### Description
Executes a GET request against the Robyn application route.

### Method
GET

### Parameters
#### Path Parameters
- **path** (str) - Required - The route path to request.

### Response
#### Success Response (200)
- **TestResponse** (object) - Returns a TestResponse object containing status_code, text, content, and headers.
```

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

### Serve HTML Files

Source: https://robyn.tech/documentation/en/api_reference/file-uploads

Uses the serve_html utility to return an HTML file from the filesystem.

```python
from robyn import Robyn, Request, serve_html

app = Robyn(__file__)


@app.get("/")
async def h(request: Request):
    return serve_html("./index.html")

app.start(port=8080)
```

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

### Create an AI Agent with Memory

Source: https://robyn.tech/documentation/en/api_reference/ai

Initialize an agent with an in-memory provider and integrate it into a Robyn route.

```python
from robyn import Robyn
from robyn.ai import agent, memory

app = Robyn(__file__)

# Create memory instance
mem = memory(provider="inmemory", user_id="user123")

# Create agent with memory
chat_agent = agent(runner="simple", memory=mem)

@app.get("/chat")
async def chat_endpoint(request):
	query = request.query_params.get("q", [""])[0]
	if not query:
		return {"error": "Query required"}
	
	# Run agent with conversation history
	result = await chat_agent.run(query, history=True)
	return result
```

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

### Return Pydantic model

Source: https://robyn.tech/documentation/en/api_reference/response-objects

Robyn serializes Pydantic models to JSON automatically. Requires pydantic to be installed.

```python
from pydantic import BaseModel
from robyn import Robyn

app = Robyn(__file__)

class User(BaseModel):
    name: str
    email: str
    age: int

@app.get("/model")
def get_model():
    return User(name="Alice", email="alice@example.com", age=30)
```

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

### Serve Directories

Source: https://robyn.tech/documentation/en/api_reference/file-uploads

Configures a route to serve an entire directory of static assets.

```python
from robyn import Robyn, serve_file, Request

app = Robyn(__file__)


app.serve_directory(
    route="/test_dir",
    directory_path=os.path.join(current_file_path, "build"),
    index_file="index.html",
)

app.start(port=8080)
```

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

### GET /items/:id

Source: https://robyn.tech/documentation/en/api_reference/request_object

Retrieves an item by ID with automatic type coercion for path and query parameters.

```APIDOC
## GET /items/:id

### Description
Retrieves an item using a path parameter and optional query parameters. Robyn automatically coerces types and handles missing required parameters with a 400 Bad Request response.

### Method
GET

### Endpoint
/items/:id

### Parameters
#### Path Parameters
- **id** (int) - Required - The unique identifier of the item.

#### Query Parameters
- **q** (string) - Required - A search query string.
- **page** (int) - Optional - The page number, defaults to 1.
```

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

### Project Directory Structure

Source: https://robyn.tech/documentation/en/api_reference/robyn_env

Shows the recommended placement of the robyn.env file within a project.

```text
--project/
  --robyn.env
  --index.py
  ...
```

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

### Robyn Module CLI Help Output

Source: https://robyn.tech/documentation/en/api_reference/getting_started

Displays available command-line arguments when running Robyn via the python module syntax.

```text

usage: python -m robyn app.py [-h] [--processes PROCESSES] [--workers WORKERS] [--dev] [--log-level LOG_LEVEL] [--create] [--docs] [--open-browser] [--version]


Robyn, a fast async web framework with a rust runtime.

options:
  -h, --help            show this help message and exit
  --processes PROCESSES
                        Choose the number of processes. [Default: 1]
  --workers WORKERS     Choose the number of workers. [Default: 1]
  --dev                 Development mode. It restarts the server based on file changes.
  --log-level LOG_LEVEL
                        Set the log level name
  --create              Create a new project template.
  --docs                Open the Robyn documentation.
  --open-browser        Open the browser on successful start.
  --version             Show the Robyn version.
  --compile-rust-path COMPILE_RUST_PATH
                        Compile rust files in the given path.
  --create-rust-file CREATE_RUST_FILE
                        Create a rust file with the given name.
  --disable-openapi     Disable the OpenAPI documentation.
  --fast                Fast mode. It sets the optimal values for processes, workers and log level. However, you can override them.
```

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

### Load Testing Configurations

Source: https://robyn.tech/documentation/en/api_reference/scaling

Use these commands to benchmark different process and worker configurations against a running application.

```bash
# Install wrk for load testing
# macOS: brew install wrk
# Ubuntu: sudo apt install wrk

# Test baseline performance
wrk -t4 -c100 -d30s http://localhost:8080/health

# Test with different configurations
# Configuration 1: Single process
python app.py --processes 1 --workers 1 &
wrk -t4 -c100 -d30s http://localhost:8080/api/endpoint

# Configuration 2: Multi-process
python app.py --processes 4 --workers 2 &
wrk -t4 -c100 -d30s http://localhost:8080/api/endpoint

# Configuration 3: Fast mode
python app.py --fast &
wrk -t4 -c100 -d30s http://localhost:8080/api/endpoint

# Compare results and choose the best configuration
```

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

### Configure Development Scaling

Source: https://robyn.tech/documentation/en/api_reference/scaling

Use these commands to run the application in development mode with optional port configuration.

```bash
# Development mode (single process, single worker)
python app.py --dev

# Development with custom port
python app.py --dev --port 3000
```

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

### GET /sync/extra/*extra

Source: https://robyn.tech/documentation/en/api_reference/request_object

Captures additional segments in the URL path after the defined route using the *extra syntax.

```APIDOC
## GET /sync/extra/*extra

### Description
Captures any additional segments in the URL path that come after the defined route. The captured segments are accessible via `request.path_params['extra']`.

### Method
GET

### Endpoint
/sync/extra/*extra

### Parameters
#### Path Parameters
- **extra** (string) - Required - The captured path segments following the base route.
```

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

### Configure Balanced Applications

Source: https://robyn.tech/documentation/en/architecture

Use this general-purpose configuration for standard web applications.

```bash
# General-purpose configuration
python app.py --processes=4 --workers=2

# Most web applications fit this pattern
```

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

### Serve Static Files and HTML

Source: https://robyn.tech/documentation/en/api_reference/cheatsheet

Serve directories, individual files as attachments, or HTML templates using built-in helpers.

```python
from robyn import serve_file, serve_html

app.serve_directory(
    route="/static",
    directory_path="./assets",
    index_file="index.html",
    show_files_listing=False,
)

@app.get("/download")
def download():
    return serve_file("./report.pdf", file_name="report.pdf")   # as an attachment

@app.get("/page")
def page():
    return serve_html("./templates/index.html")
```

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

### Generated OpenAPI JSON Schema

Source: https://robyn.tech/documentation/en/api_reference/pydantic

Example of the JSON Schema structure generated by Robyn when using Pydantic models.

```json
{
  "paths": {
    "/users": {
      "post": {
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "name": {"type": "string", "title": "Name"},
                  "email": {"type": "string", "title": "Email"},
                  "address": {"$ref": "#/components/schemas/Address"}
                },
                "required": ["name", "email", "address"],
                "title": "UserWithAddress"
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "Address": {
        "type": "object",
        "properties": {
          "street": {"type": "string", "title": "Street"},
          "city": {"type": "string", "title": "City"},
          "zip_code": {"type": "string", "title": "Zip Code"}
        },
        "required": ["street", "city", "zip_code"],
        "title": "Address"
      }
    }
  }
}
```

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

### Example validation error response

Source: https://robyn.tech/documentation/en/api_reference/pydantic

Robyn returns a 422 Unprocessable Entity response when input validation fails.

```json
{
  "error": "Validation Error",
  "detail": [
    {
      "type": "int_parsing",
      "loc": ["age"],
      "msg": "Input should be a valid integer, unable to parse string as an integer",
      "input": "not_a_number"
    }
  ]
}
```

```json
{
  "error": "Validation Error",
  "detail": [
    {
      "type": "missing",
      "loc": ["email"],
      "msg": "Field required",
      "input": {"name": "Alice", "age": 30}
    }
  ]
}
```

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

### Robyn CLI Help Output

Source: https://robyn.tech/documentation/en/api_reference/getting_started

Displays available command-line arguments for the Robyn application runner.

```text
usage: app.py [-h] [--processes PROCESSES] [--workers WORKERS] [--log-level LOG_LEVEL] [--create] [--docs] [--open-browser] [--version]

Robyn, a fast async web framework with a rust runtime.

options:
  -h, --help            show this help message and exit
  --processes PROCESSES
                        Choose the number of processes. [Default: 1]
  --workers WORKERS     Choose the number of workers. [Default: 1]
  --dev                 Development mode. It restarts the server based on file changes.
  --log-level LOG_LEVEL
                        Set the log level name
  --create              Create a new project template.
  --docs                Open the Robyn documentation.
  --open-browser        Open the browser on successful start.
  --version             Show the Robyn version.
  --compile-rust-path COMPILE_RUST_PATH
                        Compile rust files in the given path.
  --create-rust-file CREATE_RUST_FILE
                        Create a rust file with the given name.
  --disable-openapi     Disable the OpenAPI documentation.
  --fast                Fast mode. It sets the optimal values for processes, workers and log level. However, you can override them.
```

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

### Activate virtual environment

Source: https://robyn.tech/documentation/en/api_reference/graphql-support

Activate the created virtual environment.

```bash
source venv/bin/activate
```

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

### Define a route handler in Python

Source: https://robyn.tech/documentation/en/api_reference/architecture_deep_dive

Demonstrates how to define a route with parameter injection using the Robyn framework.

```python
from robyn import Robyn, Request

app = Robyn(__file__)

@app.get("/users/:id")
async def get_user(request: Request, user_id: str):
    # Business logic runs in Python
    user = await fetch_user_from_db(user_id)
    return {"user": user.to_dict()}
```

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

### Basic TestClient Usage

Source: https://robyn.tech/documentation/en/api_reference/testing

Initialize the TestClient with a Robyn app instance to perform in-process HTTP requests.

```python
from robyn import Robyn
from robyn.testing import TestClient

app = Robyn(__file__)

@app.get("/hello")
def hello(request):
    return "Hello, World!"

client = TestClient(app)

def test_hello():
    response = client.get("/hello")
    assert response.status_code == 200
    assert response.text == "Hello, World!"
```

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

### Start Multi-Worker Mode

Source: https://robyn.tech/documentation/en/api_reference/architecture_deep_dive

Configure the number of worker threads within the Python interpreter to handle concurrent requests.

```python
# Workers share the same Python interpreter
# but handle requests concurrently
app.start(port=8080, workers=4)
```

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

### Development Mode Configurations

Source: https://robyn.tech/documentation/en/api_reference/getting_started

Run the application with auto-reload enabled for local development.

```bash
# Basic development mode
python app.py --dev

# Development with custom port
python app.py --dev --port 3000

# Development with debug logging
python app.py --dev --log-level DEBUG
```

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

### Configure main.py for Railway

Source: https://robyn.tech/documentation/en/hosting

The entry point file must be named main.py and listen on the PORT environment variable.

```python
from robyn import Robyn, serve_html


app = Robyn(__file__)


@app.get("/hello")
async def h(request):
    print(request)
    return "Hello, world!"


@app.get("/")
async def get_page(request):
    return serve_html("./index.html")


if __name__ == "__main__":
    app.start(url="0.0.0.0", port=PORT)
```

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

### Disable OpenAPI via CLI

Source: https://robyn.tech/documentation/en/api_reference/openapi

Use the --disable-openapi flag when starting the application to prevent OpenAPI documentation generation.

```bash
python app.py --disable-openapi
```

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

### Run MCP Server

Source: https://robyn.tech/documentation/en/api_reference/agents

Command to initiate the MCP server process.

```bash
python examples/agents.py
```

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

### Benchmark Application Configurations

Source: https://robyn.tech/documentation/en/architecture

Test various process and worker combinations to determine the optimal performance for your specific workload.

```bash
# Test different configurations
python app.py --processes=1 --workers=1   # Baseline
python app.py --processes=2 --workers=2   # Moderate scaling
python app.py --processes=4 --workers=1   # CPU-focused
python app.py --processes=2 --workers=4   # I/O-focused
python app.py --fast                      # Auto-optimized
```
Tokens:
Raw