apunkt/rowboat
1
0
Fork 0
mirror of https://github.com/rowboatlabs/rowboat.git synced 2026-04-25 00:16:29 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Update docs and readme

Browse source
This commit is contained in:
Ramnique Singh 2025-04-03 19:58:39 +05:30 • committed by GitHub
parent 304ee9c2bf
commit 66449caa8d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
7 changed files with 174 additions and 142 deletions
Download patch file Download diff file Expand all files Collapse all files

287
README.md
View file

@ -1,11 +1,33 @@
# RowBoat
[![RowBoat Logo](/assets/rb-logo.png)](https://www.rowboatlabs.com/)
[![ui](/assets/banner.png)](https://www.rowboatlabs.com/)
RowBoat is the fastest way to build production-ready multi-agent systems with OpenAI's Agents SDK.
<h2 align="center">The AI-assisted agent builder</h2>
<h5 align="center">
[Quickstart](#quick-start) | [Docs](https://docs.rowboatlabs.com/) | [Website](https://www.rowboatlabs.com/) | [Discord](https://discord.gg/jHhUKkKHn8)
</h5>
A Cursor-like, AI-assisted, no-code IDE for building production-ready multi-agents.
- ✨ Start from a simple prompt to create fully functional agents with the Copilot
- 🧪 Test them in AI-simulated scenarios
- 🌐 Connect MCP servers and tools
- 📞 Interact through the Python SDK, a web widget, or a Twilio phone number
- ♻️ Continuously refine your agents by providing feedback to the Copilot
Built on OpenAI's Agents SDK, **Rowboat is the fastest way to build multi-agents!**
![ui](/assets/ui_revamp_screenshot.png)
# Quick start
## Prerequisites
Before running RowBoat, ensure you have:
Before running Rowboat, ensure you have:
1. **Docker Desktop**
- [Download Docker Desktop](https://www.docker.com/products/docker-desktop)
@ -20,9 +42,9 @@ Before running RowBoat, ensure you have:
brew install mongodb-community@8.0
brew services start mongodb-community@8.0
```
- Other platforms: Refer to the MongoDB documentation for details.
- Other platforms: Refer to the [MongoDB documentation](https://www.mongodb.com/docs/manual/installation/) for details.
## Quickstart
## Setup Rowboat
1. **Clone the Repository**
```bash
@ -50,27 +72,95 @@ Before running RowBoat, ensure you have:
4. **Access the App**
- Visit [http://localhost:3000](http://localhost:3000).
## Enable RAG
RowBoat supports RAG capabilities to enhance responses with your custom knowledge base. To enable RAG, you'll need:
Refer to [Docs](https://docs.rowboatlabs.com/) to learn how to start building agents with Rowboat.
1. **Qdrant Vector Database**
- **Option 1**: Use [Qdrant Cloud](https://cloud.qdrant.io/)
- Create an account and cluster
- Note your cluster URL and API key
- **Option 2**: Run Qdrant locally with Docker:
```bash
docker run -p 6333:6333 qdrant/qdrant
```
# Advanced
## 1. Tool Use
You can add your tools / APIs to Rowboat through (a) connecting MCP servers, or (b) connecting a webhook.
### 1.1 MCP Servers
You can intergrate any MCP server in Settings -> Tools -> MCP Server. The Tools on the servers will show up inside Rowboats Tools section.
### 1.2 Webhook
You can point Rowboat to any webhook in Settings -> Tools -> Webhook.
Rowboat also includes a built-in webhook service that allows you to implement custom tool functions easily. To use this feature:
1. **Generate Signing Secret**
Generate a secret for securing webhook requests:
```bash
openssl rand -hex 32
```
2. **Update Environment Variables**
```ini
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
SIGNING_SECRET=<your-generated-secret>
```
3. **Initialize Qdrant Collections**
3. **Implement Your Functions**
Add your custom functions to `apps/tools_webhook/function_map.py`:
```python
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
}
```
4. **Start the Tools Webhook Service**
```bash
docker compose --profile tools_webhook up -d
```
5. **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.
## 2. Retrieve Augmented Generation (RAG)
Rowboat supports adding text directly, document uploads or scraping URLs to enhance the responses with your custom knowledge base. Rowboat uses Qdrant as the vector DB.
### 2.1 Setup Qdrant
To enable RAG you need to first setup Qdrant.
1. Option1: Run Qdrant locally
- Run Qdrant docker
```bash
docker run -p 6333:6333 qdrant/qdrant
```
- Update environment variables
```ini
USE_RAG=true
QDRANT_URL=http://localhost:6333
QDRANT_API_KEY=<your-api-key> # Only needed for Qdrant Cloud
```
2. Option2: Use [Qdrant Cloud](https://cloud.qdrant.io/)
- Note your cluster URL and API key
- Update environment variables
```ini
USE_RAG=true
QDRANT_URL=<your-qdrant-cloud-url>
QDRANT_API_KEY=<your-api-key>
```
3. Initialize Qdrant Collections
```bash
docker compose --profile setup_qdrant up setup_qdrant
```
@ -79,39 +169,42 @@ RowBoat supports RAG capabilities to enhance responses with your custom knowledg
```bash
docker compose --profile delete_qdrant up delete_qdrant
```
### 2.2 Adding Knowledge Base for RAG
### RAG Features
You can add a knowledge corpus to Rowboat by directly adding text information, uploading supported files or by pointing Rowboat to URLs for scraping.
RowBoat supports two types of knowledge base ingestion:
#### (a) Create Text for Knowledge
#### URL Scraping
Setting up Qdrant automatically enables the RAG by adding text information inside Rowboat's RAG menu.
Enable web page scraping to build your knowledge base:
#### (b) Scrape URLs for Knowledge
1. **Get Firecrawl API Key**
Rowboat supports scraping urls using Firecrawl. To setup scraping:
1. Get Firecrawl API Key
- Sign up at [Firecrawl](https://firecrawl.co)
- Generate an API key
2. **Update Environment Variables**
2. Update Environment Variables
```ini
USE_RAG_SCRAPING=true
FIRECRAWL_API_KEY=<your-firecrawl-api-key>
```
3. **Start the URLs Worker**
3. Start the URLs Worker
```bash
docker compose --profile rag_urls_worker up -d
```
#### File Uploads
#### (c) Upload Files for Knowledge
Enable file upload support (PDF, DOCX, TXT) for your knowledge base:
Rowboat supports file uploads (PDF, DOCX, TXT) for your knowledge base. It uses Google's Gemini LLM to convert the documents to Markdown before indexing:
1. **Prerequisites**
1. Prerequisites
- An AWS S3 bucket for file storage
- Google Cloud API key with Generative Language (Gemini) API enabled (for enhanced document parsing)
2. **Configure AWS S3**
2. Configure AWS S3
- Create an S3 bucket
- Add the following CORS configuration to your bucket:
```json
@ -158,7 +251,7 @@ Enable file upload support (PDF, DOCX, TXT) for your knowledge base:
}
```
3. **Update Environment Variables**
3. Update Environment Variables
```ini
USE_RAG_UPLOADS=true
AWS_ACCESS_KEY_ID=<your-aws-access-key>
@ -168,63 +261,16 @@ Enable file upload support (PDF, DOCX, TXT) for your knowledge base:
GOOGLE_API_KEY=<your-google-api-key>
```
4. **Start the Files Worker**
4. Start the Files Worker
```bash
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`.
After enabling RAG and starting the required workers, you can manage your knowledge base through the Rowboat UI at `/projects/<PROJECT_ID>/sources`.
## Enable Tools Webhook
## 3. Chat Widget
RowBoat includes a built-in webhook service that allows you to implement custom tool functions. To use this feature:
1. **Generate Signing Secret**
Generate a secret for securing webhook requests:
```bash
openssl rand -hex 32
```
2. **Update Environment Variables**
```ini
SIGNING_SECRET=<your-generated-secret>
```
3. **Implement Your Functions**
Add your custom functions to `apps/tools_webhook/function_map.py`:
```python
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
}
```
4. **Start the Tools Webhook Service**
```bash
docker compose --profile tools_webhook up -d
```
5. **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.
## Enable Chat Widget
RowBoat provides an embeddable chat widget that you can add to any website. To enable and use the chat widget:
Rowboat provides an embeddable chat widget that you can add to any website. To enable and use the chat widget:
1. **Generate JWT Secret**
Generate a secret for securing chat widget sessions:
@ -246,42 +292,12 @@ RowBoat provides an embeddable chat widget that you can add to any website. To e
4. **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.
After setup, the chat widget will appear on your website and connect to your Rowboat project.
## Enable Authentication
By default, RowBoat runs without authentication. To enable user authentication using Auth0:
### 4. Interact with Rowboat API
1. **Auth0 Setup**
- **Create an Auth0 Account**: Sign up at [Auth0](https://auth0.com).
- **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:
```bash
openssl rand -hex 32
```
2. **Update Environment Variables**
Add the following to your `.env` file:
```ini
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.
## Interact with RowBoat API
There are two ways to interact with RowBoat's API:
There are two ways to interact with Rowboat's API:
1. **Option 1: Python SDK**
@ -351,18 +367,35 @@ There are two ways to interact with RowBoat's API:
}
```
## Troubleshooting
### 5. Authentication
1. **MongoDB Connection Issues**
- Ensure local MongoDB service is running: `brew services list`
- Verify connection string and network connectivity.
By default, Rowboat runs without authentication. To enable user authentication using Auth0:
2. **Container Start-up Issues**
- Remove all containers: `docker-compose down`
- Rebuild: `docker-compose up --build`
1. **Auth0 Setup**
- **Create an Auth0 Account**: Sign up at [Auth0](https://auth0.com).
- **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:
```bash
openssl rand -hex 32
```
3. **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://`.
2. **Update Environment Variables**
Add the following to your `.env` file:
```ini
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.
## Attribution
Our agents framework is built on top of [OpenAI Swarm](https://github.com/openai/swarm) with custom enhancements and improvements. Check the [NOTICE](https://github.com/rowboatlabs/rowboat/blob/main/apps/agents/NOTICE.md) for attribution and license.