mirror of
https://github.com/Routstr/routstr-core.git
synced 2026-10-05 20:28:23 +00:00
redshift
fd0b379d7b
The deployment page led with a third-party all-in-one Docker Hub image (`9qeklajc/routstr`) that is not published by this repo's release workflow, while the Tor and pre-config examples pulled `ghcr.io/routstr/proxy` and built from source — three different starting points for the same node. Lead with the supported path instead: clone the repo at a release tag, copy `.env.example` to `.env`, and `docker compose up -d`, which builds the node and dashboard from source. - Drop the all-in-one image section and its compose snippet. - Add the clone/release checkout steps, including `cp .env.example .env` (compose declares `env_file: .env`, so `up` fails without it). - Fold the duplicate Tor compose example into a pointer to `tor.md`, since the default `compose.yml` already runs Tor. - Correct the persistence table: with `.:/app` mounted, state lives in the clone (`keys.db`, `routstr_secret.key`, `.wallet/`), not `/app/data`. - Document `--build` on updates and the first-start build time. - README quick start: add the missing clone step to match.
122 lines
4.1 KiB
Markdown
122 lines
4.1 KiB
Markdown
# Routstr Payment Proxy
|
|
|
|
[](LICENSE)
|
|
[](https://github.com/routstr/routstr-core/stargazers)
|
|
[](https://github.com/routstr/routstr-core/issues)
|
|
[](https://github.com/routstr/routstr-core/releases)
|
|
|
|
Routstr is a decentralized protocol for permissionless, private, and censorship-resistant AI inference. It combines Nostr for discovery and Cashu for private Bitcoin micropayments.
|
|
|
|
This repo contains Routstr Core: a FastAPI-based reverse proxy that sits in front of OpenAI-compatible APIs and handles pay-per-request billing.
|
|
|
|
## Start Here
|
|
|
|
- **Overview**: <https://docs.routstr.com/overview/>
|
|
- **Provider Guide**: <https://docs.routstr.com/provider/quickstart/>
|
|
- **User Guide**: <https://docs.routstr.com/user-guide/introduction/>
|
|
|
|
## Basic Usage
|
|
|
|
If you are a user/developer, you just point an OpenAI-compatible SDK at a Routstr node and pay with a Cashu token.
|
|
|
|
### OpenAI SDK
|
|
|
|
```python
|
|
from openai import OpenAI
|
|
|
|
client = OpenAI(
|
|
base_url="https://api.routstr.com/v1",
|
|
api_key="cashuBo2FteCJodHRwczovL21...",
|
|
)
|
|
|
|
response = client.chat.completions.create(
|
|
model="gpt-5-nano",
|
|
messages=[{"role": "user", "content": "hello"}],
|
|
)
|
|
|
|
print(response.choices[0].message.content)
|
|
```
|
|
|
|
### cURL
|
|
|
|
```bash
|
|
curl https://api.routstr.com/v1/chat/completions \
|
|
-H "Content-Type: application/json" \
|
|
-H "x-cashu: cashuBo2FteCJodHRwczovL21..." \
|
|
-d '{
|
|
"model": "gpt-5-nano",
|
|
"messages": [{"role": "user", "content": "hello"}]
|
|
}'
|
|
```
|
|
|
|
## Quick Start (Docker)
|
|
|
|
If you are a node runner, the recommended way to start Routstr Core is to clone
|
|
the repository at the latest release and run it with Docker Compose:
|
|
|
|
1. **Clone the latest release**:
|
|
```bash
|
|
git clone https://github.com/Routstr/routstr-core.git
|
|
cd routstr-core
|
|
git checkout v0.4.7 # current release — see https://github.com/Routstr/routstr-core/releases/latest
|
|
```
|
|
|
|
Docker Compose builds the node and the admin dashboard from source, so there
|
|
is no image to pull.
|
|
|
|
2. **Prepare your `.env`**:
|
|
```bash
|
|
cp .env.example .env
|
|
```
|
|
|
|
Then edit it with your details:
|
|
```bash
|
|
# Optional: encrypts node secrets at rest. If unset, the node generates a key
|
|
# on first start, writes it to routstr_secret.key, and prints it once — back
|
|
# up that file. Set it explicitly to manage the key yourself (recommended in
|
|
# production).
|
|
ROUTSTR_SECRET_KEY=<generated-key>
|
|
NAME="My AI Node"
|
|
DESCRIPTION="Fast access to models"
|
|
RECEIVE_LN_ADDRESS=yourname@wallet.com
|
|
```
|
|
|
|
Your Nostr identity (`nsec`) is not set in `.env` — configure it from the admin
|
|
UI after first start, where it's stored encrypted in the database. (`NSEC` in
|
|
`.env` is still read once as a legacy seed for existing deployments.)
|
|
|
|
If you don't set one, a key is generated and printed on first start — save it
|
|
somewhere safe (losing it makes previously encrypted secrets unreadable). To
|
|
supply your own, generate it once and keep it stable:
|
|
```bash
|
|
uv run python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
|
|
```
|
|
|
|
3. **Start the services**:
|
|
```bash
|
|
docker compose up -d
|
|
```
|
|
|
|
The first start builds both images (the dashboard build takes a few minutes).
|
|
|
|
4. **Get your admin password**:
|
|
On first start the node generates an admin password and logs it once with the
|
|
`/admin` URL. Read it from the logs:
|
|
```bash
|
|
docker compose logs routstr | grep -i admin
|
|
```
|
|
(Lost it? Reset with `docker compose exec routstr /.venv/bin/python scripts/reset_admin_password.py --regenerate`.)
|
|
|
|
5. **Configure**:
|
|
Open [http://localhost:8000/admin/](http://localhost:8000/admin/) to connect your AI providers and set pricing.
|
|
|
|
For full instructions, see the **[Provider Quick Start Guide](https://docs.routstr.com/provider/quickstart/)**.
|
|
|
|
## Development
|
|
|
|
```bash
|
|
make setup
|
|
cp .env.example .env
|
|
fastapi run routstr
|
|
```
|