aibo/BoosAPI
1
0
Fork 0
forked from boos/BoosAPI
Code Pull Requests Activity

feat(desktop): embed BoosAPI Desktop client as a subproject

Browse Source 
Vendor the rebranded BoosAPI Desktop client (Tauri + Vue) into metapi as
a monorepo subdirectory under desktop/. Source only — node_modules,
dist, Cargo target and the upstream .git history are excluded.

desktop/ keeps its own independent Cargo workspace (desktop/src-tauri
with crates/*); it is not part of the backend boosapi crate, so a
`cargo check` at the metapi root still compiles only the backend. Build
the desktop app from desktop/src-tauri per desktop/README.md.

Note: app icons are still placeholder assets pending the final BoosAPI
logo. The updater signing keys live outside the repo and are not
included.
This commit is contained in:
boos
2026-06-22 11:32:57 +08:00
parent d9c78ecc73
commit e0a5f57793
2305 changed files with 449355 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
desktop/website/docs/de/guide/gateway.md
+74
View File
@@ -0,0 +1,74 @@
# API-Gateway
## Was ist das API-Gateway?
BoosApi enthält einen integrierten lokalen API-Server, der Ihre konfigurierten Anbieter als **OpenAI-kompatible**, **Claude-native** und **Gemini-native** Endpoints exponiert. Jedes Tool oder jeder Client, der eines dieser Protokolle verwendet, kann BoosApi als Backend verwenden — keine separaten API-Schlüssel oder Relay-Dienste erforderlich.
Anwendungsfälle:
- Führen Sie **Claude Code CLI**, **OpenAI Codex CLI**, **Gemini CLI** oder **OpenCode** über BoosApi aus.
- Verbinden Sie Ihre IDE-Erweiterungen mit einem einzigen, lokal verwalteten Endpoint.
- Teilen Sie einen Satz von Anbieter-Schlüsseln über viele Tools mit schlüsselbasiertem Rate-Limiting.
---
## Erste Schritte
1. Öffnen Sie **Einstellungen → API-Gateway** (oder drücken Sie <kbd>Cmd/Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>G</kbd>).
2. Klicken Sie auf **Starten**, um den Gateway-Server zu starten.
3. Standardmäßig lauscht der Server auf `127.0.0.1:8080` (HTTP).
::: tip
Aktivieren Sie **Auto-Start** in den Gateway-Einstellungen, um den Server automatisch beim Start von BoosApi zu starten.
:::
---
## API-Schlüsselverwaltung
1. Gehen Sie zum Tab **API-Schlüssel**.
2. Klicken Sie auf **Neuen Schlüssel generieren**.
3. Fügen Sie optional eine **Beschreibung** hinzu (z.B. *Claude Code*, *VS Code*).
4. Kopieren Sie den Schlüssel — er wird nur einmal angezeigt.
---
## Konfigurationsvorlagen
### Claude Code CLI
```bash
claude config set --global apiUrl http://127.0.0.1:8080
claude config set --global apiKey boosapi-xxxx
```
### OpenAI Codex CLI
```bash
export OPENAI_BASE_URL=http://127.0.0.1:8080/v1
export OPENAI_API_KEY=boosapi-xxxx
codex
```
### Gemini CLI
```bash
export GEMINI_API_BASE=http://127.0.0.1:8080
export GEMINI_API_KEY=boosapi-xxxx
gemini
```
### Benutzerdefinierter Client
```
Base URL: http://127.0.0.1:8080/v1
API-Schlüssel: boosapi-xxxx
```
---
## Nächste Schritte
- [Schnellstart](./getting-started) — Zum Schnellstartleitfaden zurückkehren
- [Anbieter konfigurieren](./providers) — Die Upstream-Anbieter hinzufügen, zu denen das Gateway routet
- [MCP-Server](./mcp) — Externe Tools für KI-Tool-Aufruf verbinden
desktop/website/docs/de/guide/getting-started.md
+128
View File
@@ -0,0 +1,128 @@
# Schnellstart
## Installation
Laden Sie den neuesten Installer von der [Download-Seite](/de/download) oder [GitHub Releases](https://github.com/BoosApi-Desktop/BoosApi/releases) herunter.
### macOS
| Chip | Datei |
|------|-------|
| Apple Silicon (M1 / M2 / M3 / M4) | `BoosApi_x.x.x_aarch64.dmg` |
| Intel | `BoosApi_x.x.x_x64.dmg` |
1. Öffnen Sie die `.dmg` und ziehen Sie **BoosApi** in den **Programme**-Ordner.
2. Starten Sie BoosApi. Wenn macOS die App blockiert, gehen Sie zu **Systemeinstellungen → Datenschutz & Sicherheit** und klicken Sie auf **Trotzdem öffnen**.
::: warning macOS: „App ist beschädigt" oder „Entwickler kann nicht überprüft werden"
Wenn Sie eine dieser Meldungen sehen, öffnen Sie Terminal und führen Sie aus:
```bash
xattr -c /Applications/BoosApi.app
```
Starten Sie die App dann erneut. Dies entfernt das Quarantäne-Flag, das macOS auf unsignierte Downloads anwendet.
:::
### Windows
| Architektur | Datei |
|-------------|-------|
| x64 (die meisten PCs) | `BoosApi_x.x.x_x64-setup.exe` |
| ARM64 | `BoosApi_x.x.x_arm64-setup.exe` |
Führen Sie den Installer aus und folgen Sie dem Assistenten. Starten Sie BoosApi über das Startmenü oder die Desktop-Verknüpfung.
### Linux
| Format | Architektur | Datei |
|--------|-------------|-------|
| Debian / Ubuntu | x64 | `BoosApi_x.x.x_amd64.deb` |
| Debian / Ubuntu | ARM64 | `BoosApi_x.x.x_arm64.deb` |
| Fedora / openSUSE | x64 | `BoosApi_x.x.x_x86_64.rpm` |
| Fedora / openSUSE | ARM64 | `BoosApi_x.x.x_aarch64.rpm` |
| Beliebige Distribution | x64 | `BoosApi_x.x.x_amd64.AppImage` |
| Beliebige Distribution | ARM64 | `BoosApi_x.x.x_aarch64.AppImage` |
```bash
# Debian / Ubuntu
sudo dpkg -i BoosApi_x.x.x_amd64.deb
# Fedora / openSUSE
sudo rpm -i BoosApi_x.x.x_x86_64.rpm
# AppImage (beliebige Distribution)
chmod +x BoosApi_x.x.x_amd64.AppImage
./BoosApi_x.x.x_amd64.AppImage
```
---
## Ersteinrichtung
### 1. Einstellungen öffnen
Starten Sie BoosApi und klicken Sie auf das **Zahnrad-Symbol** unten in der Seitenleiste, oder drücken Sie <kbd>Cmd/Ctrl</kbd>+<kbd>,</kbd>.
### 2. Anbieter hinzufügen
Navigieren Sie zu **Einstellungen → Anbieter** und klicken Sie auf die Schaltfläche **+**.
1. Geben Sie einen Anzeigenamen ein (z.B. *OpenAI*).
2. Wählen Sie den Anbietertyp (OpenAI, Anthropic, Google Gemini usw.).
3. Fügen Sie Ihren API-Schlüssel ein.
4. Bestätigen Sie die **Base URL** — für integrierte Typen ist der offizielle Endpoint vorausgefüllt.
::: tip
Sie können beliebig viele Anbieter hinzufügen. Jeder Anbieter verwaltet seine eigenen API-Schlüssel und Modelle unabhängig.
:::
### 3. Modelle abrufen
Klicken Sie auf **Modelle abrufen**, um die Liste der verfügbaren Modelle von der API des Anbieters zu laden. Sie können Modell-IDs auch manuell hinzufügen.
### 4. Standardmodell festlegen
Gehen Sie zu **Einstellungen → Standardmodell** und wählen Sie den Anbieter und das Modell, das neue Gespräche standardmäßig verwenden sollen.
---
## Ihr erstes Gespräch
1. Klicken Sie auf **Neuer Chat** in der Seitenleiste (oder drücken Sie <kbd>Cmd/Ctrl</kbd>+<kbd>N</kbd>).
2. Wählen Sie ein Modell aus dem Modell-Selektor oben im Chat.
3. Geben Sie eine Nachricht ein und drücken Sie <kbd>Enter</kbd>.
4. BoosApi streamt die Antwort in Echtzeit. Modelle mit Denkblöcken (z.B. Claude, DeepSeek R1) zeigen den Reasoning-Prozess in einem einklappbaren Bereich.
---
## Tastenkürzel
| Kürzel | Aktion |
|--------|--------|
| <kbd>Cmd/Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>A</kbd> | Aktuelles Fenster ein-/ausblenden |
| <kbd>Cmd/Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Alt</kbd>+<kbd>A</kbd> | Alle Fenster ein-/ausblenden |
| <kbd>Cmd/Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>W</kbd> | Fenster schließen |
| <kbd>Cmd/Ctrl</kbd>+<kbd>N</kbd> | Neues Gespräch |
| <kbd>Cmd/Ctrl</kbd>+<kbd>,</kbd> | Einstellungen öffnen |
| <kbd>Cmd/Ctrl</kbd>+<kbd>K</kbd> | Befehlspalette |
| <kbd>Cmd/Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>G</kbd> | API-Gateway umschalten |
---
## Daten und Backup
### Datenverzeichnisse
| Pfad | Inhalt |
|------|--------|
| `~/.boosapi/` | Anwendungszustand — Datenbank, Verschlüsselungsschlüssel, Vektor-DB, SSL-Zertifikate |
| `~/Documents/boosapi/` | Benutzerdateien — Bilder, Dokumente, Backups |
---
## Nächste Schritte
- [Anbieter konfigurieren](./providers) — KI-Anbieter hinzufügen und verwalten
- [MCP-Server](./mcp) — Externe Tools zur Erweiterung der KI-Fähigkeiten verbinden
- [API-Gateway](./gateway) — Ihre Anbieter als lokalen API-Server exponieren
desktop/website/docs/de/guide/mcp.md
+64
View File
@@ -0,0 +1,64 @@
# MCP-Server
## Was ist MCP?
Das [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) ist ein offener Standard, der es KI-Modellen ermöglicht, mit externen Tools und Datenquellen zu interagieren. BoosApi fungiert als MCP-Client — Sie fügen MCP-Server hinzu, und die KI kann die von ihnen bereitgestellten Tools während eines Gesprächs aufrufen.
---
## Transportprotokolle
BoosApi unterstützt drei Transportprotokolle für die Kommunikation mit MCP-Servern:
| Protokoll | Verbindung | Anwendungsfall | Konfiguration |
|-----------|-----------|----------------|--------------|
| **Stdio** | Lokaler Prozess | Tools auf Ihrem Rechner, gestartet via `npx`, `uvx`, `python` usw. | `command` + `args` + optionales `env` |
| **SSE** | Remote-Server | Server-Sent Events-Endpoint auf einem Remote-Server | `url` |
| **StreamableHTTP** | Remote-Server | HTTP-Streaming-Endpoint, neuere Alternative zu SSE | `url` |
---
## MCP-Server hinzufügen
### Formular-Erstellung
1. Gehen Sie zu **Einstellungen → MCP-Server**.
2. Klicken Sie auf **MCP-Server hinzufügen**.
3. Geben Sie einen Namen ein und wählen Sie das Transportprotokoll.
4. Füllen Sie die Felder für Ihr gewähltes Protokoll aus.
5. Klicken Sie auf **Speichern**.
### JSON-Import
Klicken Sie auf **JSON-Import** und fügen Sie ein Konfigurationsobjekt ein. BoosApi akzeptiert das Standard-MCP-JSON-Format:
```json
{
"mcpServers": {
"fetch": {
"command": "uvx",
"args": ["mcp-server-fetch"]
}
}
}
```
---
## Integrierte Tools
| Tool | Beschreibung |
|------|-------------|
| **@boosapi/fetch** | Webseiten und HTTP-Ressourcen abrufen |
| **@boosapi/search-file** | Dateien im lokalen Dateisystem suchen |
---
## Tool-Loop-Limit
Unter Settings -> MCP können Sie die maximale Anzahl aufeinanderfolgender Tool-Call-Iterationen für eine MCP-Antwort konfigurieren. Reduzieren Sie das Limit beim Testen unbekannter Server oder erhöhen Sie es für Workflows, die mehrere Tools bewusst verketten.
## Nächste Schritte
- [API-Gateway](./gateway) — Ihre Anbieter als lokalen API-Server exponieren
- [Schnellstart](./getting-started) — Zum Schnellstartleitfaden zurückkehren
desktop/website/docs/de/guide/providers.md
+145
View File
@@ -0,0 +1,145 @@
# Anbieter konfigurieren
BoosApi verbindet sich gleichzeitig mit beliebig vielen KI-Anbietern. Jeder Anbieter hat seine eigenen API-Schlüssel, Modellliste und Parameterstandards.
## Unterstützte Anbieter
| Anbieter | Beispielmodelle |
|---------|----------------|
| **OpenAI** | GPT-4o, GPT-4, o3, o4-mini |
| **Anthropic** | Claude 4 Sonnet, Claude 4 Opus, Claude 3.5 Sonnet |
| **Google** | Gemini 2.5 Pro, Gemini 2.5 Flash, Gemini 2.0 |
| **DeepSeek** | DeepSeek V3, DeepSeek R1 |
| **Alibaba Cloud** | Qwen-Serie |
| **Zhipu AI** | GLM-Serie |
| **xAI** | Grok-Serie |
| **OpenAI-kompatible API** | Ollama, vLLM, LiteLLM, Drittanbieter-Relays usw. |
---
## Anbieter hinzufügen
1. Gehen Sie zu **Einstellungen → Anbieter**.
2. Klicken Sie auf die Schaltfläche **+** unten links.
3. Füllen Sie die Anbieterdetails aus:
| Feld | Beschreibung |
|------|-------------|
| **Name** | Anzeigename für die Seitenleiste (z.B. *OpenAI*) |
| **Typ** | Anbietertyp — bestimmt Standard-Base-URL und API-Verhalten |
| **Symbol** | Optionales Symbol zur visuellen Identifikation |
| **API-Schlüssel** | Der geheime Schlüssel aus dem Dashboard Ihres Anbieters |
| **Base URL** | API-Endpoint (für integrierte Typen vorausgefüllt) |
| **API-Pfad** | Anfragepfad — Standard ist `/v1/chat/completions` |
---
## Import über Website-Link
Anbieter-Websites, Relay-Dashboards, private Modellplattformen oder lokale Gateway-Seiten können einen Link **In BoosApi öffnen** bereitstellen. Beim Klick öffnet der Browser die BoosApi-Desktop-App, BoosApi wechselt zu **Einstellungen → Anbieter**, zeigt einen Bestätigungsdialog und importiert die Konfiguration erst nach Bestätigung durch den Benutzer.
### Benutzerablauf
1. Installieren und öffnen Sie eine BoosApi-Version, die Anbieterlinks unterstützt.
2. Klicken Sie im Browser auf den Link **In BoosApi öffnen** des Anbieters.
3. Prüfen Sie in BoosApi Anbietername, Base URL, Anbietertyp und API-Schlüssel-Präfix.
4. BoosApi verwendet einen bestehenden Anbieter mit derselben Kombination aus **Base URL + Typ** wieder. Falls keiner existiert, wird ein neuer Anbieter erstellt; der API-Schlüssel wird nur hinzugefügt, wenn er noch nicht vorhanden ist.
BoosApi validiert den Schlüssel nicht automatisch und ruft Modelle nicht automatisch ab. Klicken Sie nach dem Import auf **Modelle abrufen** oder fügen Sie Modelle manuell hinzu.
### Linkformat
```text
boosapi://providers?name=<name>&baseurl=<base-url>&apikey=<api-key>&type=<provider-type>
```
Beispiel:
```text
boosapi://providers?name=OpenAI&baseurl=https%3A%2F%2Fapi.openai.com&apikey=sk-xxx&type=openai
```
### Parameter
| Parameter | Erforderlich | Beschreibung |
|-----------|--------------|--------------|
| `name` | Ja | Anzeigename in BoosApi, z. B. `OpenAI` oder `My Relay` |
| `baseurl` | Ja | URL-kodierte Base URL. Nur `http` und `https` sind erlaubt; query und hash werden abgelehnt. |
| `apikey` | Ja | API-Schlüssel, der in BoosApi gespeichert wird. BoosApi zeigt im Bestätigungsdialog nur ein Präfix. |
| `type` | Ja | Anbietertyp. Erlaubte Werte: `openai`, `openai_responses`, `anthropic`, `gemini`, `custom`. |
`baseurl` kann die bestehende Force-Suffix-Semantik von BoosApi verwenden, z. B. `https://example.com!`. Beim Import per Link wird `api_path` nicht gesetzt; BoosApi nutzt weiterhin den Standardpfad des gewählten Anbietertyps.
### Website-Konfiguration
Kodieren Sie alle dynamischen Werte mit `encodeURIComponent` oder `URLSearchParams`:
```html
<a id="open-boosapi" href="#">In BoosApi öffnen</a>
<script>
const provider = {
name: 'My Relay',
baseurl: 'https://api.example.com',
apikey: 'sk-user-key',
type: 'openai',
};
const params = new URLSearchParams({
name: provider.name,
baseurl: provider.baseurl,
apikey: provider.apikey,
type: provider.type,
});
document.getElementById('open-boosapi').href = `boosapi://providers?${params.toString()}`;
</script>
```
Wenn Ihr Dienst API-Schlüssel online erzeugt, erstellen Sie den Link erst, nachdem der Benutzer angemeldet ist und ausdrücklich einen Schlüssel ausgewählt oder erstellt hat.
::: warning Sicherheit
Ein API-Schlüssel in einer URL kann im Browserverlauf, in Logs, Erweiterungen oder Analysewerkzeugen sichtbar werden. Platzieren Sie echte Schlüssel nicht auf öffentlichen Seiten, in statischem HTML oder in Drittanbieter-Weiterleitungen. Erzeugen Sie den Link vorzugsweise auf einer privaten Kontoseite nach Benutzerbestätigung.
:::
::: tip Test
`boosapi://` ist ein benutzerdefiniertes Protokoll, das von der installierten Desktop-App im System registriert wird. Nur die Website oder den Vite-Entwicklungsserver auszuführen registriert das Protokoll nicht. Wenn der Link BoosApi nicht öffnet, installieren oder bauen Sie zuerst die aktuelle BoosApi-Desktop-App neu.
:::
---
## Aus CC Switch importieren
BoosApi kann CC Switch-Providerkonfigurationen unter Settings -> Providers scannen. Prüfen Sie Kandidaten, wählen Sie importierbare Zeilen aus und importieren Sie Provider, Base URLs, API Keys und Modelllisten. OAuth-only Einträge oder Einträge ohne wiederverwendbare Schlüssel werden mit sichtbarem Grund übersprungen.
## Erweiterter Modell-Request-Body
Jedes Modell kann extra_body definieren, ein JSON-Objekt, das flach zu OpenAI-kompatiblen Chat Completions Requests hinzugefügt wird. Das ist nützlich für Anbieteroptionen wie enable_thinking. BoosApi validiert JSON und verhindert das Überschreiben von model, messages, stream, tools und Basis-Sampling-Feldern.
## Multi-Key-Rotation
BoosApi unterstützt mehrere API-Schlüssel pro Anbieter. Klicken Sie auf **Schlüssel hinzufügen** im Anbieter-Detailpanel.
---
## Modellverwaltung
Klicken Sie auf **Modelle abrufen** im Anbieter-Detailpanel, um die vollständige Liste der verfügbaren Modelle zu laden. Sie können Modell-IDs auch manuell eingeben.
Jedes Modell kann eigene Standardparameterüberschreibungen haben: Temperatur, Max. Tokens, Top P, Häufigkeitsstrafe, Präsenzstrafe.
---
## Ollama (lokale Modelle)
1. Installieren und starten Sie [Ollama](https://ollama.com/).
2. Erstellen Sie in BoosApi einen neuen Anbieter mit Typ **OpenAI**.
3. Setzen Sie die **Base URL** auf `http://localhost:11434`.
4. Klicken Sie auf **Modelle abrufen**, um lokal heruntergeladene Modelle zu entdecken.
---
## Nächste Schritte
- [MCP-Server](./mcp) — Externe Tools zur Erweiterung der KI-Fähigkeiten verbinden
- [API-Gateway](./gateway) — Ihre Anbieter als lokalen API-Server exponieren