mirror of https://github.com/rowboatlabs/rowboat.git synced 2026-04-25 16:36:22 +02:00

Ramnique Singh 861bae11a6 make auth optional

2025-03-27 07:58:15 +05:30

12 KiB

Raw Blame History

RowBoat

This guide will help you set up and run the RowBoat applications locally using Docker. Please see our docs for more details.

RowBoat offers several optional services that can be enabled using Docker Compose profiles. You can run multiple profiles simultaneously using:

docker compose --profile rag_urls_worker --profile chat_widget --profile tools_webhook up -d

See the relevant sections below for details on each service.

Prerequisites
Local Development Setup
- Python SDK
- HTTP API
Optional Features
Troubleshooting
Attribution

Prerequisites

Before running RowBoat, ensure you have:

Docker Desktop
- Download Docker Desktop
OpenAI API Key
- Obtain from your OpenAI account.
MongoDB
- Option 1: Use an existing MongoDB deployment with your connection string.
- Option 2: Install MongoDB locally:
```
brew tap mongodb/brew
brew install mongodb-community@8.0
brew services start mongodb-community@8.0
```

Local Development Setup

Clone the Repository

git clone git@github.com:rowboatlabs/rowboat.git
cd rowboat

Environment Configuration

Copy the .env.example file and rename it to .env:
```
cp .env.example .env
```

Update your .env file with the following configurations:

# OpenAI Configuration
OPENAI_API_KEY=your-openai-api-key

# MongoDB Configuration (choose one based on your setup)
# For local MongoDB
MONGODB_CONNECTION_STRING=mongodb://host.docker.internal:27017/rowboat 
# or, for remote MongoDB
MONGODB_CONNECTION_STRING=mongodb+srv://<username>:<password>@<cluster>.mongodb.net/rowboat

Start the App
```
docker-compose up --build
```
Access the App
- Visit http://localhost:3000.

Interact with RowBoat

There are two ways to interact with RowBoat:

Option 1: Python SDK

For Python applications, we provide an official SDK for easier integration:

pip install rowboat

from rowboat import Client

client = Client(
    host="http://localhost:3000",
    project_id="<PROJECT_ID>",
    api_key="<API_KEY>"  # Generate this from /projects/<PROJECT_ID>/config
)

# Simple chat interaction
messages = [{"role": "user", "content": "Tell me the weather in London"}]
response_messages, state = client.chat(messages=messages)

For more details, see the Python SDK documentation.

Option 2: HTTP API

You can use the API directly at http://localhost:3000/api/v1/

Project ID is available in the URL of the project page
API Key can be generated from the project config page at /projects/<PROJECT_ID>/config

curl --location 'http://localhost:3000/api/v1/<PROJECT_ID>/chat' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer <API_KEY>' \
--data '{
    "messages": [
        {
            "role": "user",
            "content": "tell me the weather in london in metric units"
        }
    ]
}'

which gives:

{
    "messages": [
        {
            "role": "assistant",
            "tool_calls": [
                {
                    "function": {
                        "arguments": "{\"location\":\"London\",\"units\":\"metric\"}",
                        "name": "weather_lookup_tool"
                    },
                    "id": "call_r6XKuVxmGRogofkyFZIacdL0",
                    "type": "function"
                }
            ],
            "agenticSender": "Example Agent",
            "agenticResponseType": "internal"
        }
    ],
    "state": {
        // .. state data
    }
}

Documentation

The documentation site is available at http://localhost:8000

Enable Authentication

By default, RowBoat runs without authentication. To enable user authentication using Auth0:

Auth0 Setup
- Create an Auth0 Account: Sign up at Auth0.
- Create a New Application: Choose "Regular Web Application", select "Next.js" as the application type, and name it "RowBoat".
- Configure Application:
  - Allowed Callback URLs: In the Auth0 Dashboard, go to your "RowBoat" application settings and set http://localhost:3000/api/auth/callback as an Allowed Callback URL.
- Get Credentials: Collect the following from your Auth0 application settings:
  - Domain: Copy your Auth0 domain (ensure you append https:// to the Domain that the Auth0 dashboard shows you)
  - Client ID: Your application's unique identifier
  - Client Secret: Your application's secret key
- Generate secret: Generate a session encryption secret in your terminal and note the output for later:
```
openssl rand -hex 32
```

Update Environment Variables Add the following to your .env file:

USE_AUTH=true
AUTH0_SECRET=your-generated-secret               # Generated using openssl command
AUTH0_BASE_URL=http://localhost:3000             # Your application's base URL
AUTH0_ISSUER_BASE_URL=https://example.auth0.com  # Your Auth0 domain (ensure it is prefixed with https://)
AUTH0_CLIENT_ID=your-client-id
AUTH0_CLIENT_SECRET=your-client-secret

After enabling authentication, users will need to sign in to access the application.

Enable RAG

RowBoat supports RAG capabilities to enhance responses with your custom knowledge base. To enable RAG, you'll need:

Qdrant Vector Database
- Option 1: Use Qdrant Cloud
  - Create an account and cluster
  - Note your cluster URL and API key
- Option 2: Run Qdrant locally with Docker:
```
docker run -p 6333:6333 qdrant/qdrant
```

Update Environment Variables

USE_RAG=true
QDRANT_URL=<your-qdrant-url>  # e.g., http://localhost:6333 for local
QDRANT_API_KEY=<your-api-key>  # Only needed for Qdrant Cloud

Initialize Qdrant Collections

docker compose --profile setup_qdrant up setup_qdrant

If you need to delete the collections and start fresh, you can run:

docker compose --profile delete_qdrant up delete_qdrant

RAG Features

RowBoat supports two types of knowledge base ingestion:

URL Scraping

Enable web page scraping to build your knowledge base:

Get Firecrawl API Key
- Sign up at Firecrawl
- Generate an API key

Update Environment Variables

USE_RAG_SCRAPING=true
FIRECRAWL_API_KEY=<your-firecrawl-api-key>

Start the URLs Worker

docker compose --profile rag_urls_worker up -d

File Uploads

Enable file upload support (PDF, DOCX, TXT) for your knowledge base:

Prerequisites
- An AWS S3 bucket for file storage
- Google Cloud API key with Generative Language (Gemini) API enabled (for enhanced document parsing)

Configure AWS S3

Create an S3 bucket

Add the following CORS configuration to your bucket:

[
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "PUT",
            "POST",
            "DELETE",
            "GET"
        ],
        "AllowedOrigins": [
            "http://localhost:3000",
        ],
        "ExposeHeaders": [
            "ETag"
        ]
    }
]

Ensure your AWS credentials have the following IAM policy:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": [
                "s3:PutObject",
                "s3:GetObject",
                "s3:DeleteObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::<your-bucket-name>/*",
                "arn:aws:s3:::<your-bucket-name>"
            ]
        }
    ]
}

Update Environment Variables

USE_RAG_UPLOADS=true
AWS_ACCESS_KEY_ID=<your-aws-access-key>
AWS_SECRET_ACCESS_KEY=<your-aws-secret-key>
RAG_UPLOADS_S3_BUCKET=<your-s3-bucket-name>
RAG_UPLOADS_S3_REGION=<your-s3-region>
GOOGLE_API_KEY=<your-google-api-key>

Start the Files Worker

docker compose --profile rag_files_worker up -d

After enabling RAG and starting the required workers, you can manage your knowledge base through the RowBoat UI at /projects/<PROJECT_ID>/sources.

RowBoat provides an embeddable chat widget that you can add to any website. To enable and use the chat widget:

Generate JWT Secret Generate a secret for securing chat widget sessions:
```
openssl rand -hex 32
```

Update Environment Variables

USE_CHAT_WIDGET=true
CHAT_WIDGET_SESSION_JWT_SECRET=<your-generated-secret>

Start the Chat Widget Service

docker compose --profile chat_widget up -d

Add Widget to Your Website You can find the chat-widget embed code under /projects/<PROJECT_ID>/config

After setup, the chat widget will appear on your website and connect to your RowBoat project.

Enable Tools Webhook

RowBoat includes a built-in webhook service that allows you to implement custom tool functions. To use this feature:

Generate Signing Secret Generate a secret for securing webhook requests:
```
openssl rand -hex 32
```
Update Environment Variables
```
SIGNING_SECRET=<your-generated-secret>
```

Implement Your Functions Add your custom functions to apps/tools_webhook/function_map.py:

def get_weather(location: str, units: str = "metric"):
    """Return weather data for the given location."""
    # Your implementation here
    return {"temperature": 20, "conditions": "sunny"}

def check_inventory(product_id: str):
    """Check inventory levels for a product."""
    # Your implementation here
    return {"in_stock": 42, "warehouse": "NYC"}

# Add your functions to the map
FUNCTIONS_MAP = {
    "get_weather": get_weather,
    "check_inventory": check_inventory
}

Start the Tools Webhook Service

docker compose --profile tools_webhook up -d

Register Tools in RowBoat
- Navigate to your project config at /projects/<PROJECT_ID>/config
- Ensure that the webhook URL is set to: http://tools_webhook:3005/tool_call
- Tools will automatically be forwarded to your webhook implementation

The webhook service handles all the security and parameter validation, allowing you to focus on implementing your tool logic.

Troubleshooting

MongoDB Connection Issues
- Ensure local MongoDB service is running: brew services list
- Verify connection string and network connectivity.
Container Start-up Issues
- Remove all containers: docker-compose down
- Rebuild: docker-compose up --build
Sign-in Button Not Appearing
- If the sign-in button does not appear in the UI, ensure the Auth0 domain in your .env file is prefixed with https://.

Attribution

Our agents framework is built on top of OpenAI Swarm with custom enhancements and improvements. Check the NOTICE for attribution and license.

12 KiB

Raw Blame History

RowBoat

Table of Contents

Prerequisites

Local Development Setup

Option 1: Python SDK

Option 2: HTTP API

Enable Authentication

Enable RAG

RAG Features

URL Scraping

File Uploads

Enable Chat Widget

Enable Tools Webhook

Troubleshooting

Attribution

12 KiB Raw Blame History

RowBoat

Table of Contents

Prerequisites

Local Development Setup

Option 1: Python SDK

Option 2: HTTP API

Enable Authentication

Enable RAG

RAG Features

URL Scraping

File Uploads

Enable Chat Widget

Enable Tools Webhook

Troubleshooting

Attribution

12 KiB

Raw Blame History