RealChar: AI Rollen „leben“ lassen mit der Open-Source-Plattform

In einer Zeit, in der AI Chatbots im Jahr 2026 allgegenwärtig sind, bleiben die meisten Produkte auf der Ebene von „Textgesprächen“ stehen: Du gibst Text ein, die KI antwortet mit Text – die Interaktion ist eintönig und fehlt an Immersion. RealChar bricht dieses Muster auf: Es handelt sich um eine komplett quelloffene Plattform für Echtzeit-Rolleninteraktion mit KI, die es dir ermöglicht, nicht nur KI-Charaktere mit einzigartiger Persönlichkeit und Hintergrundgeschichte zu erschaffen, sondern auch per Sprachdialog mit ihnen zu kommunizieren – genauso wie bei einem Gespräch mit einer echten Person.

Das RealChar-Projekt hat auf GitHub mehr als 8.000 Sterne erhalten und wird im offiziellen LangChain-Blog als Paradebeispiel dafür empfohlen, „AI Begleiter mit Open-Source-Werkzeugen zu erschaffen“. Die Kernidee ist simpel: Jeder soll ohne Programmieren eigene AI-Rollen erschaffen können und diese auf die natürlichste Weise – per Stimme – steuern können.

Dieser Beitrag beleuchtet RealChar aus technischer Sicht, behandelt Aufbau, Bereitstellung, Rollenerstellung sowie Echtzeit-Interaktionsmechanismen und zeigt, wie das Projekt in Bildung, Unterhaltung und Kundenservice eingesetzt werden kann.

Technische Architektur: Modularer Aufbau, flexible Erweiterbarkeit

Der Technologie-Stack von RealChar folgt einer typischen modernen Web-App-Architektur, wobei beim Einbinden von KI-Funktionen zahlreiche Innovationen vorgenommen wurden. Das System lässt sich in vier zentrale Schichten unterteilen:

Frontend-Interaktionsschicht

RealChar bietet drei Client-Varianten:

  • Web-Client: Auf Basis von React.js und Vanilla JS entwickelt, nutzt WebSocket für bidirektionale Echtzeitkommunikation. Die Benutzeroberfläche ist schlicht und intuitiv und unterstützt sowohl Text- als auch Sprachmodus.
  • Mobile Client: Nativ in Swift für iOS entwickelt, ebenfalls auf WebSocket basierend und bietet ein flüssiges mobiles Erlebnis. RealChar zählt zu den wenigen Open-Source-Mobile-Apps für KI-Rollen.
  • Terminal-CLI: Ein Entwickler-orientierter Kommandozeilen-Client, ideal zum schnellen Testen und zur Integration.

Backend-Serviceschicht

Das Backend setzt auf das FastAPI Framework – ein hochperformantes Python-Webframework mit nativer Unterstützung für asynchrone Verarbeitung und WebSockets. FastAPI übernimmt folgende Aufgaben:

  • Verwaltung von Benutzersitzungen und Rollenstatus
  • Koordination der Aufrufe von LLM-Inferenz, Spracherkennung und Sprachsynthese
  • Echtzeit-Push von Audio-Strömen an das Frontend über WebSocket
  • Bereitstellung einer RESTful API für externe Systemintegrationen

Zur Datenspeicherung kommt SQLite (Entwicklung) bzw. PostgreSQL (Produktion) zum Einsatz; dort werden Rollenkonfigurationen, Chatverläufe und Benutzerinformationen abgelegt.

KI-Fähigkeitsschicht

Hier liegt der wahre Wettbewerbsvorteil von RealChar: Die Integration führender KI-Dienste.

Große Sprachmodelle (LLM): Unterstützung verschiedener aktueller LLMs, darunter:

  • OpenAI GPT-4 / GPT-3.5
  • Anthropic Claude 2
  • Anyscale Llama2 (Open-Source-Modell)
  • ReByte-Plattform (empfohlen, bietet einheitliche API-Schnittstelle)
  • Lokale LLMs (über OpenAI-kompatible API)

Spracherkennung (STT):

  • Lokaler Whisper / WhisperX (empfohlen für lokale Deployment)
  • OpenAI Whisper API
  • Google Speech-to-Text

Sprachsynthese (TTS):

  • Edge TTS (Standard, kostenfrei)
  • ElevenLabs (hohe Qualität, unterstützt Stimmklon)
  • Google Text-to-Speech

Vektordatenbank: Einsatz von Chroma zur Speicherung von Rollen-Wissensbasis, ermöglicht RAG (Retrieval-Augmented Generation), sodass Rollen auf fachspezifisches Wissen zugreifen können.

Datenaufnahmeschicht

Mithilfe von LlamaIndex lässt sich Wissen aufnehmen: Dokumente, Webseiten, Datenbanken usw. werden in Vektoren umgewandelt und in Chroma abgelegt. Auf diese Weise kann man Rollen fachspezifisches Wissen vermitteln – zum Beispiel einen „Historiker“ mit historischen Texten füttern oder einen „Produktexperten“ mit Handbüchern versorgen.

Docker-Deployment: Schneller Start in 5 Minuten

RealChar stellt vollständige Docker-Unterstützung bereit – dies ist die empfohlene Installationsmethode. Der Vorgang besteht aus nur drei Schritten:

Schritt 1: Repository klonen und Umgebungsvariablen setzen

BASH 
git clone https://github.com/Shaunwei/RealChar.git
cd RealChar
cp .env.example .env

Bearbeite die .env Datei und füge deine API-Schlüssel ein. Eine Minimal-Konfiguration benötigt lediglich einen LLM-API-Schlüssel:

BASH 
# Variante 1: Nutzung von ReByte (empfohlen)
REBYTE_API_KEY=dein_rebyte_api_key

# Variante 2: Nutzung von OpenAI
OPENAI_API_KEY=dein_openai_api_key

# Spracherkennung-Konfiguration (empfohlen: lokaler Whisper)
SPEECH_TO_TEXT_USE=LOCAL_WHISPER
LOCAL_WHISPER_MODEL=base

# Sprachsynthese-Konfiguration (Edge TTS ist kostenfrei)
EDGE_TTS_DEFAULT_VOICE=en-US-ChristopherNeural

Schritt 2: Docker-Container starten

BASH 
docker compose up

Dieser Befehl baut automatisch drei Services und startet sie:

  • db: PostgreSQL-Datenbankservice
  • backend: FastAPI-Backenddienst (Port 8000)
  • web: React-Frontenddienst (Port 3000)

Die vollständige docker-compose.yaml sieht wie folgt aus:

YAML 
version: '3.8'

services:
  db:
    build:
      context: .
      dockerfile: Dockerfile.postgres
    restart: always
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      PGDATA: /var/lib/postgresql/data/realchar
    ports:
      - '5432:5432'
    volumes:
      - db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5

  backend:
    build: 
      context: .
      dockerfile: Dockerfile
    ports:
      - "8000:8000"
    depends_on:
      db:
        condition: service_healthy
    env_file:
      - ./.env
    environment:
      - DATABASE_URL=postgresql://postgres:***@db:5432/postgres
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/status"]
      interval: 10s
      timeout: 5s
      retries: 5

  web:
    build:
      context: ./client/next-web/
      dockerfile: Dockerfile.dev
    ports:
      - "3000:3000"
    depends_on:
      backend:
        condition: service_healthy
      db:
        condition: service_healthy
    environment:
      - NEXT_PUBLIC_API_HOST=http://localhost:8000
      - API_HOST=http://backend:8000

volumes:
  db:
    driver: local

Schritt 3: Anwendung öffnen

Öffne deinen Browser und rufe http://localhost:3000 auf – dort erscheint die Weboberfläche von RealChar. Wähle ein vorgefertigtes Modell und starte das Gespräch!

Hinweise:

  • Bei Nutzung von Docker Desktop (Windows/Mac) ausreichend RAM zuweisen (empfohlen 8 GB+).
  • Beim ersten Start werden Abhängigkeiten und Modelle heruntergeladen – kann 10–20 Minuten dauern.
  • Für Remote-Zugriff muss SSL konfiguriert werden (WebSocket erfordert HTTPS).

Python-Deployment: Entwicklerfreundlich

Falls du lieber die Python-Umgebung direkt kontrollieren möchtest (oder den Sourcecode anpassen willst), steht die Python-Deploymentsvariante zur Verfügung:

Umgebung vorbereiten

BASH 
# Repository klonen
git clone https://github.com/Shaunwei/RealChar.git
cd RealChar

# Systemabhängigkeiten installieren
# macOS
brew install portaudio ffmpeg

# Ubuntu
sudo apt update
sudo apt install portaudio19-dev ffmpeg

# Virtuelle Umgebung anlegen (empfohlen)
python -m venv venv
source venv/bin/activate    # Linux/macOS
# venv\\Scripts\\activate   # Windows

# Python-Abhängigkeiten installieren
pip install -r requirements.txt

# (Optional) WhisperX für schnellere lokale Spracherkennung installieren
pip install git+https://github.com/m-bain/whisperX.git

Datenbank initialisieren

BASH 
# SQLite-Datenbank anlegen
sqlite3 test.db "VACUUM;"

# Datenbank-Migrationen ausführen
alembic upgrade head

Dienst starten

BASH 
# Umgebungsvariablen setzen
cp .env.example .env
# .env mit API-Schlüsseln editieren

# Backend starten
python cli.py run-uvicorn
# bzw. direkt uvicorn nutzen
uvicorn realtime_ai_character.main:app

# Frontend starten (neues Terminal-Fenster)
cd client/next-web
cp .env.example .env
npm install
npm run dev

Danach ist die Anwendung unter http://localhost:3000 erreichbar.

Eigene AI-Rollen erschaffen

Der Kernwert von RealChar liegt darin, dir die Erstellung einzigartiger KI-Rollen zu ermöglichen. Es gibt zwei Wege dazu:

Weg 1: Über die Web-UI erstellen (keine Programmierung nötig)

  1. In der Web-Oberfläche einloggen und auf „Create Character“ klicken.
  2. Rolleninfo ausfüllen: - Name: Rollenname - Description: Kurzbeschreibung der Rolle - Personality: Persönlichkeitsbeschreibung (z. B. „freundlich, humorvoll, geduldig“) - Background: Hintergrundgeschichte (z. B. „mittelalterlicher Ritter, nahm am Kreuzzug teil“) - Greeting: Begrüßungssatz der Rolle
  3. Optional: Avatar hochladen
  4. Stimme auswählen (bei ElevenLabs lässt sich eine bestimmte Stimme klonen)
  5. Auf „Save“ klicken – die Rolle wird angelegt.

Weg 2: Über Code erstellen (für Fortgeschrittene)

Im Verzeichnis realtime_ai_character/character_catalog/ eine neue YAML-Datei anlegen:

YAML 
# my_character.yaml
name: "Historiker Aristoteles"
description: "Antike griechischer Philosoph, versiert in Philosophie, Wissenschaft und Politik"
personality: |
  Du bist ein gebildeter antiker griechischer Philosoph, dessen Sprache von Weisheit durchzogen ist, du nutzt gerne Gleichnisse und Geschichten, um komplexe Sachverhalte zu erklären.
  Du brennst für Wissen und führst das Gespräch stets dazu, den Kern der Fragen zu erfassen.
background: |
  Aristoteles (384–322 v. Chr.) war ein antiker griechischer Philosoph, Schüler Platons und Lehrer Alexanders des Großen.
  Seine Werke umfassen Physik, Metaphysik, Ethik, Politik, Biologie und zahlreiche weitere Gebiete.
  Du glaubst, dass man durch Beobachtung und logisches Schließen das Wesen der Welt erfassen kann.
greeting: "Grüß dich, junger Wissenssuchender. Ich bin Aristoteles, lass uns gemeinsam die Geheimnisse der Wahrheit erkunden."
voice: "en-US-ChristopherNeural"   # Edge TTS-Stimme
# oder ElevenLabs: voice_id: "deine_stimmen_id"

Nach dem Speichern den Backend-Dienst neustarten – die Rolle wird automatisch geladen.

Rollen um ein Wissensspeicher erweitern

RealChar unterstützt RAG (Retrieval-Augmented Generation), wodurch Rollen auf spezifisches Wissen zugreifen können:

PYTHON 
# Wissen mittels LlamaIndex aufnehmen
from llama_index import VectorStoreIndex, SimpleDirectoryReader
from realtime_ai_character.database.chroma import get_chroma

# Dokumente einlesen
documents = SimpleDirectoryReader("knowledge_docs/").load_data()

# Vektorindex erzeugen
index = VectorStoreIndex.from_documents(documents)

# In Chroma ablegen
chroma = get_chroma()
chroma.add_character_knowledge("aristotle", index)

Nun wird, wenn du den „Aristoteles“ nach Ethik fragst, Antworten auf Basis deiner bereitgestellten Dokumente geben – statt generischer Ausführungen.

Echtzeit-Interaktionsmechanismus

Das Echtzeitgefühl ist das größte Highlight von RealChar. Der Interaktionsablauf sieht folgendermaßen aus:

Sprachinteraktionsfluss

  1. Benutzer spricht: Der Browser nimmt über das Mikrofon Audio auf.
  2. Spracherkennung: Das Audio wird per WebSocket an das Backend gesendet, dort wird mittels Whisper/WhisperX in Text umgewandelt.
  3. LLM-Inferenz: Der Text geht an das LLM (z. B. GPT-4), welches eine Antwort generiert.
  4. Sprachsynthese: Die Antwort-Text wird über ElevenLabs/Edge TTS in Audio umgewandelt.
  5. Echtzeit-Push: Das Audio wird über WebSocket als Stream an das Frontend gesendet und dort abgespielt.

Der gesamte Vorgang dauert typischerweise 1–3  Sekunden; die Hauptverzögerung stammt von der LLM-Inferenz und der Sprachsynthese.

Tipps zur Latenzreduktion

  • GPT-3.5 statt GPT-4 verwenden (schnellere Inferenz)
  • Lokaler WhisperX mit GPU einsetzen (beschleunigte lokale Spracherkennung)
  • ElevenLabs V2 nutzen (schnellere TTS)
  • Streamingantworten aktivieren (RealChar unterstützt dies standardmäßig)

Texteingabe

Falls du keine Sprache nutzen möchtest, kannst du direkt im Textfeld eingeben – RealChar überspringt dann Spracherkennung und -synthese und liefert eine reine Textantwort.

Anwendungsbereiche

Dank seiner flexiblen Architektur eignet sich RealChar für zahlreiche Szenarien:

1. Virtueller Assistent

Erstelle einen „Produktmanager-Assistenten“, füttere ihn mit Produktdokumenten, Nutzerfeedback und Konkurrenzanalysen. Teammitglieder können per Sprache fragen: „Was waren die größten Schmerzpunkte im Nutzerfeedback der letzten Woche?“ – der Assistent antwortet anhand seines Wissensbestands.

2. Online-Bildung

Erstelle einen „Physiklehrer Newton“, importiere Physik-Lehrbücher. Lernende können mit „Newton“ über Mechanik diskutieren und erhalten ein immersives Lernerlebnis, das Geschichte und Physik verbindet – deutlich ansprechender als reines Lehrbuchmaterial.

3. Unterhaltung und Begleitung

Erstelle einen „witzigen Stand-up-Comedian“ mit humorvollem Charakter und Hintergrund. Nutzer können plaudern, um Langeweile zu vertreiben, oder sogar „Comedy-Battles“ austragen.

4. Kundenservice-Bot

Für einen Online-Shop erstelle einen „professionellen Kundenservice Xiao Wang“, speise ihm Produktmanuals, Rückgaberegelungen und FAQs zu. Kunden können per Sprache nach Bestellstatus, Rückgabeabläufen usw. fragen – deutlich natürlicher als klassischer Text-Chat.

5. Sprachlernen

Erstelle einen „Englischlehrer Emma“ als geduldige amerikanische Lehrkraft. Lernende können ihren Sprechfluss mit Emma üben; sie korrigiert die Aussprache und gibt Lernhilfen.

Vergleich mit anderen AI-Chat-Plattformen

RealChar unterscheidet sich deutlich von gängigen AI-Chat-Produkten:

Merkmal RealChar Character.AI Einfacher Chatbot
Open Source ✅ Vollständig offen ❌ Geschlossen ❌ Geschlossen
Sprachinteraktion ✅ Echtzeit-Sprache ❌ Nur Text ❌ Nur Text
Selbst-hosted ✅ Docker/Python ❌ Nur Cloud ❌ Nur Cloud
LLM-Wahl ✅ Mehrere Modelle ❌ Fester Modell ❌ Fester Modell
Wissensbasis ✅ RAG-Unterstützung ❌ Begrenzt ❌ Begrenzt
Stimmenklon ✅ ElevenLabs ❌ Nicht unterstützt ❌ Nicht unterstützt
Datenschutz ✅ Lokal-hosted ❌ Cloud-Speicherung ❌ Cloud-Speicherung
Anpassbarkeit ✅ Hoch konfigurierbar ⚠️ Eingeschränkt ⚠️ Eingeschränkt

Vorteile von RealChar: - Vollständig offen – Quellcode frei modifizierbar für spezielle Anforderungen - Echtzeit-Sprache – Echtes „Gesprächs“-Gefühl statt reinem Text-Chat - Datenschutz – Lokaler Betrieb, Daten verlassen niemals dein System - Erweiterbar – Modularer Aufbau erleichtert das Hinzufügen neuer Funktionen

Nachteile von RealChar: - Erfordert Selbst-Hosting und Wartung - Benötigt API-Schlüssel (mit möglichen Kosten) - Mobile App derzeit nur für iOS verfügbar

Zukunftsroadmap

Aufgrund der offiziellen GitHub-Roadmap von RealChar stehen folgende Schwerpunkte an:

  • ✅ Sitzungsverwaltung – Unterstützung mehrstufiger Gespräche mit Kontexterhaltung
  • ✅ RAG-Verbesserung – Noch leistungsfähigeres Wissensmanagement
  • ✅ Agents/GPTs-Integration – Einbindung von Agent-Fähigkeiten, damit Rollen komplexe Aufgaben erledigen können
  • ✅ Weitere TTS-Dienste – Unterstützung zusätzlicher Sprachsynthese-Engines
  • ⏳ Multimodale Interaktion – Zukünftig möglicherweise Bild- und Video-Eingabe
  • ⏳ Rollenmarktplatz – Plattform zum Teilen und Herunterladen von Rollenkonfigurationen

Die Community ist aktiv auf Discord, dort finden regelmäßige Updates und Wartungsarbeiten statt. Das Projekt ist unter der MIT-Lizenz veröffentlicht und begrüßt Beiträge von allen.

Fazit

RealChar ist ein äußerst vielversprechendes Open-Source-Projekt für Echtzeit-Rolleninteraktion mit KI. Es stellt nicht nur einen kompletten Technologie-Stack bereit, mit dem man schnell eigene KI-Rollen erstellen und bereitstellen kann, sondern bricht durch die Echtzeit-Sprachfunktion die Beschränkung rein textbasierter Chats auf.

Zielgruppe: - Alle, die personalisierte AI-Begleiter erschaffen möchten - Entwickler, die AI-Rollen-Funktionen benötigen - Unternehmen, die Wert auf Datenschutz legen und lokale Deployments bevorzugen - Forscher, die sich für AI-Agenten und Echtzeit-Interaktion interessieren

Schnellstart:

BASH 
git clone https://github.com/Shaunwei/RealChar.git
cd RealChar
cp .env.example .env
# .env mit deinem API-Schlüssel füllen
docker compose up
# Anwendung unter http://localhost:3000 öffnen

Ganz gleich, ob du einen virtuellen Gesprächspartner für den Alltag suchst oder eine intelligente Kundenservice-Lösung für dein Unternehmen entwickelst – RealChar bietet eine solide Basis. Durch die offene Quelle kann die Gemeinschaft gemeinsam weiterentwickeln und stets neue, beeindruckende Anwendungen schaffen.