Erste Schritte

🌐 Andere Sprachen

Deutsch

Dieser Leitfaden führt Sie durch die Einrichtung von Symbi und die Erstellung Ihres ersten KI-Agenten.

Inhaltsverzeichnis

Voraussetzungen
1. Erforderliche Abhängigkeiten
2. Optionale Abhängigkeiten
Installation
Ihr erster Agent
1. 1. Agenten-Definition erstellen
2. 2. Agent ausführen
Die DSL verstehen
Nächste Schritte
1. Beispiele erkunden
2. Erweiterte Funktionen aktivieren
  1. HTTP API (Optional)
  2. Vektordatenbank-Integration
Konfiguration
1. Umgebungsvariablen
2. Laufzeitkonfiguration
Häufige Probleme
Hilfe erhalten
Was kommt als nächstes?

Voraussetzungen

Bevor Sie mit Symbi beginnen, stellen Sie sicher, dass Sie Folgendes installiert haben:

Erforderliche Abhängigkeiten

Docker (für containerisierte Entwicklung)
Rust 1.88+ (wenn Sie lokal kompilieren)
Git (zum Klonen des Repositories)

Optionale Abhängigkeiten

Qdrant Vektordatenbank (für semantische Suchfunktionen)
SchemaPin Go CLI (für Tool-Verifizierung)

Installation

Option 1: Docker (Empfohlen)

Der schnellste Weg zum Einstieg ist die Verwendung von Docker:

# Repository klonen
git clone https://github.com/thirdkeyai/symbiont.git
cd symbiont

# Einheitlichen symbi-Container erstellen
docker build -t symbi:latest .

# Oder vorgefertigten Container verwenden
docker pull ghcr.io/thirdkeyai/symbi:latest

# Entwicklungsumgebung ausführen
docker run --rm -it -v $(pwd):/workspace symbi:latest bash

Option 2: Lokale Installation

Für lokale Entwicklung:

# Repository klonen
git clone https://github.com/thirdkeyai/symbiont.git
cd symbiont

# Rust-Abhängigkeiten installieren und kompilieren
cargo build --release

# Tests ausführen, um die Installation zu überprüfen
cargo test

Installation überprüfen

Testen Sie, ob alles korrekt funktioniert:

# DSL-Parser testen
cd crates/dsl && cargo run && cargo test

# Laufzeitsystem testen
cd ../runtime && cargo test

# Beispiel-Agenten ausführen
cargo run --example basic_agent
cargo run --example full_system

# Einheitliche symbi CLI testen
cd ../.. && cargo run -- dsl --help
cargo run -- mcp --help

# Mit Docker-Container testen
docker run --rm symbi:latest --version
docker run --rm -v $(pwd):/workspace symbi:latest dsl parse --help
docker run --rm symbi:latest mcp --help

Ihr erster Agent

Lassen Sie uns einen einfachen Datenanalyse-Agenten erstellen, um die Grundlagen von Symbi zu verstehen.

1. Agenten-Definition erstellen

Erstellen Sie eine neue Datei my_agent.dsl:

metadata {
    version = "1.0.0"
    author = "your-name"
    description = "My first Symbi agent"
}

agent greet_user(name: String) -> String {
    capabilities = ["greeting", "text_processing"]
    
    policy safe_greeting {
        allow: read(name) if name.length <= 100
        deny: store(name) if name.contains_sensitive_data
        audit: all_operations with signature
    }
    
    with memory = "ephemeral", privacy = "low" {
        if (validate_name(name)) {
            greeting = format_greeting(name);
            audit_log("greeting_generated", greeting.metadata);
            return greeting;
        } else {
            return "Hello, anonymous user!";
        }
    }
}

2. Agent ausführen

# Agenten-Definition parsen und validieren
cargo run -- dsl parse my_agent.dsl

# Agent in der Laufzeitumgebung ausführen
cd crates/runtime && cargo run --example basic_agent -- --agent ../../my_agent.dsl

Die DSL verstehen

Die Symbi DSL hat mehrere Hauptkomponenten:

Metadaten-Block

metadata {
    version = "1.0.0"
    author = "developer"
    description = "Agent description"
}

Stellt wesentliche Informationen über Ihren Agenten für Dokumentation und Laufzeitverwaltung bereit.

Agenten-Definition

agent agent_name(parameter: Type) -> ReturnType {
    capabilities = ["capability1", "capability2"]
    // Agenten-Implementierung
}

Definiert die Schnittstelle, Fähigkeiten und das Verhalten des Agenten.

Richtlinien-Definitionen

policy policy_name {
    allow: action_list if condition
    deny: action_list if condition
    audit: operation_type with audit_method
}

Deklarative Sicherheitsrichtlinien, die zur Laufzeit durchgesetzt werden.

Ausführungskontext

with memory = "persistent", privacy = "high" {
    // Agenten-Implementierung
}

Spezifiziert Laufzeitkonfiguration für Speicherverwaltung und Datenschutzanforderungen.

Nächste Schritte

Beispiele erkunden

Das Repository enthält mehrere Beispiel-Agenten:

# Grundlegender Agent-Beispiel
cd crates/runtime && cargo run --example basic_agent

# Vollständige Systemdemonstration
cd crates/runtime && cargo run --example full_system

# Kontext- und Speicher-Beispiel
cd crates/runtime && cargo run --example context_example

# RAG-verstärkter Agent
cd crates/runtime && cargo run --example rag_example

Erweiterte Funktionen aktivieren

HTTP API (Optional)

# HTTP API-Funktion aktivieren
cd crates/runtime && cargo build --features http-api

# Mit API-Endpunkten ausführen
cd crates/runtime && cargo run --features http-api --example full_system

Wichtige API-Endpunkte:

GET /api/v1/health - Gesundheitsprüfung und Systemstatus
GET /api/v1/agents - Alle aktiven Agenten auflisten
POST /api/v1/workflows/execute - Arbeitsabläufe ausführen

Vektordatenbank-Integration

Für semantische Suchfunktionen:

# Qdrant-Vektordatenbank starten
docker run -p 6333:6333 qdrant/qdrant

# Agent mit RAG-Funktionen ausführen
cd crates/runtime && cargo run --example rag_example

Konfiguration

Umgebungsvariablen

Richten Sie Ihre Umgebung für optimale Leistung ein:

# Grundkonfiguration
export SYMBI_LOG_LEVEL=info
export SYMBI_RUNTIME_MODE=development

# Vektordatenbank (optional)
export QDRANT_URL=http://localhost:6333

# MCP-Integration (optional)
export MCP_SERVER_URLS="http://localhost:8080"

Laufzeitkonfiguration

Erstellen Sie eine symbi.toml-Konfigurationsdatei:

[runtime]
max_agents = 1000
memory_limit_mb = 512
execution_timeout_seconds = 300

[security]
default_sandbox_tier = "docker"
audit_enabled = true
policy_enforcement = "strict"

[vector_db]
enabled = true
url = "http://localhost:6333"
collection_name = "symbi_knowledge"

Häufige Probleme

Docker-Probleme

Problem: Docker-Build schlägt mit Berechtigungsfehlern fehl

# Lösung: Sicherstellen, dass Docker-Daemon läuft und Benutzer Berechtigungen hat
sudo systemctl start docker
sudo usermod -aG docker $USER

Problem: Container beendet sich sofort

# Lösung: Docker-Logs überprüfen
docker logs <container_id>

Rust-Build-Probleme

Problem: Cargo-Build schlägt mit Abhängigkeitsfehlern fehl

# Lösung: Rust aktualisieren und Build-Cache löschen
rustup update
cargo clean
cargo build

Problem: Fehlende Systemabhängigkeiten

# Ubuntu/Debian
sudo apt-get update
sudo apt-get install build-essential pkg-config libssl-dev

# macOS
brew install pkg-config openssl

Laufzeit-Probleme

Problem: Agent startet nicht

# Agenten-Definitionssyntax überprüfen
cargo run -- dsl parse your_agent.dsl

# Debug-Protokollierung aktivieren
RUST_LOG=debug cd crates/runtime && cargo run --example basic_agent

Hilfe erhalten

Dokumentation

DSL-Leitfaden - Vollständige DSL-Referenz
Laufzeit-Architektur - Details zur Systemarchitektur
Sicherheitsmodell - Sicherheits- und Richtliniendokumentation

Community-Support

Issues: GitHub Issues
Diskussionen: GitHub Discussions
Dokumentation: Vollständige API-Referenz

Debug-Modus

Für die Fehlerbehebung detaillierte Protokollierung aktivieren:

# Debug-Protokollierung aktivieren
export RUST_LOG=symbi=debug

# Mit detaillierter Ausgabe ausführen
cd crates/runtime && cargo run --example basic_agent 2>&1 | tee debug.log

Was kommt als nächstes?

Jetzt, da Sie Symbi zum Laufen gebracht haben, erkunden Sie diese fortgeschrittenen Themen:

DSL-Leitfaden - Erweiterte DSL-Funktionen lernen
Laufzeit-Architektur - Systeminternas verstehen
Sicherheitsmodell - Sicherheitsrichtlinien implementieren
Beitragen - Zum Projekt beitragen

Bereit, etwas Großartiges zu bauen? Beginnen Sie mit unseren Beispielprojekten oder tauchen Sie in die vollständige Spezifikation ein.