RealChar : donner vie aux personnages IA grâce à la plateforme open-source

À l'ère des chatbots IA omniprésents en 2026, la plupart des produits restent au stade de la « conversation textuelle » : vous entrez du texte, l'IA répond en texte, l'interaction est monotone et manque d'immersion. RealChar brise ce schéma : il s'agit d'une plateforme entièrement open-source d'interaction en temps réel avec des personnages IA, permettant non seulement de créer des personnages IA dotés d'une personnalité et d'un historique uniques, mais aussi de leur parler par la voix, comme avec une vraie personne.

Le projet RealChar a dépassé les 8 000 étoiles sur GitHub et est recommandé par le blog officiel de LangChain comme exemple typique de « création de compagnons IA avec des outils open-source ». Son idée centrale est simple : permettre à chacun de créer son personnage IA sans code, puis d'interagir avec lui de la manière la plus naturelle – par la voix.

Cet article examine RealChar sous tous ses aspects techniques : architecture, déploiement, création de personnages et mécanisme d'interaction en temps réel, tout en explorant son potentiel dans l'éducation, le divertissement et le service client.

Architecture technique : conception modulaire, extensibilité flexible

La pile technologique de RealChar suit une architecture typique d'application web moderne, tout en intégrant de nombreuses innovations dans le domaine de l'IA. Le système peut être divisé en quatre couches centrales :

Couche d'interaction frontend

RealChar propose trois types de clients :

  • Client Web : basé sur React.js et Vanilla JS, utilisant WebSocket pour une communication bidirectionnelle en temps réel. L'interface est épurée et intuitive, prenant en charge les modes texte et voix.
  • Client mobile : développé nativement en Swift pour iOS, également basé sur WebSocket, offrant une expérience mobile fluide. RealChar fait partie des rares applications mobiles open-source pour personnages IA.
  • CLI Terminal : interface en ligne de commande destinée aux développeurs, idéale pour des tests rapides et des intégrations.

Couche de services backend

Le backend s'appuie sur le framework FastAPI, un framework web Python haute performance qui prend en charge nativement le traitement asynchrone et WebSocket. FastAPI s'occupe de :

  • Gestion des sessions utilisateur et des états des personnages
  • Orchestration des appels à l'inférence des LLM, à la reconnaissance vocale et à la synthèse vocale
  • Envoi en temps réel de flux audio vers le frontend via WebSocket
  • Exposition d'une API RESTful pour l'intégration avec des systèmes externes

Le stockage des données utilise SQLite (en développement) ou PostgreSQL (en production), où sont enregistrées les configurations des personnages, l'historique des conversations et les informations utilisateur.

Couche des capacités IA

C'est ici que réside le véritable avantage concurrentiel de RealChar : l'intégration de services IA de pointe.

Modèles de langage à grande échelle (LLM) : prise en charge de plusieurs LLM majeurs, notamment :

  • OpenAI GPT-4 / GPT-3.5
  • Anthropic Claude 2
  • Anyscale Llama2 (modèle open-source)
  • Plateforme ReByte (recommandée, fournit une API unifiée)
  • LLM locaux (via API compatible OpenAI)

Reconnaissance vocale (STT) :

  • Whisper / WhisperX local (recommandé pour un déploiement local)
  • API Whisper d'OpenAI
  • Google Speech-to-Text

Synthèse vocale (TTS) :

  • Edge TTS (par défaut, gratuit)
  • ElevenLabs (haute qualité, prend en charge la clonage de voix)
  • Google Text-to-Speech

Base de données vectorielle : utilisation de Chroma pour stocker la base de connaissances des personnages, permettant le RAG (Retrieval-Augmented Generation) afin que les personnages puissent s'appuyer sur des connaissances spécifiques à un domaine.

Couche d'ingestion des données

Grâce à LlamaIndex, il est possible d'ingérer des connaissances : documents, pages web, bases de données, etc., sont convertis en vecteurs et stockés dans Chroma. Ainsi, on peut doter un personnage de connaissances spécialisées – par exemple, fournir à un personnage « historien » des textes historiques ou à un personnage « expert produit » des manuels d'utilisation.

Déploiement Docker : démarrage rapide en 5 minutes

RealChar offre un support complet pour Docker – c'est la méthode de déploiement recommandée. Le processus ne comporte que trois étapes :

Étape 1 : Cloner le dépôt et définir les variables d'environnement

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

Éditez le fichier .env et ajoutez vos clés API. Une configuration minimale nécessite uniquement une clé API LLM :

BASH 
# Option 1 : utilisation de ReByte (recommandée)
REBYTE_API_KEY=votre_clé_api_rebyte

# Option 2 : utilisation d'OpenAI
OPENAI_API_KEY=votre_clé_api_openai

# Configuration de la reconnaissance vocale (recommandé : Whisper local)
SPEECH_TO_TEXT_USE=LOCAL_WHISPER
LOCAL_WHISPER_MODEL=base

# Configuration de la synthèse vocale (Edge TTS est gratuit)
EDGE_TTS_DEFAULT_VOICE=en-US-ChristopherNeural

Étape 2 : Lancer les conteneurs Docker

BASH 
docker compose up

Cette commande construit et démarre automatiquement trois services :

  • db : service de base de données PostgreSQL
  • backend : service backend FastAPI (port 8000)
  • web : service frontend React (port 3000)

La configuration complète de docker-compose.yaml ressemble à ceci :

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

Étape 3 : Accéder à l'application

Ouvrez votre navigateur et accédez à http://localhost:3000 : vous verrez l'interface web de RealChar. Sélectionnez un personnage prédéfini et commencez à discuter !

Remarques :

  • Si vous utilisez Docker Desktop (Windows/Mac), assurez-vous d'allouer suffisamment de mémoire (recommandé : 8 Go+).
  • Au premier lancement, le téléchargement des dépendances et des modèles peut prendre 10–20 minutes.
  • Pour un accès distant, il faut configurer SSL (WebSocket exige HTTPS).

Déploiement en Python : adapté aux développeurs

Si vous préférez contrôler directement l'environnement Python (ou modifier le code source), vous pouvez utiliser le déploiement en Python :

Préparation de l'environnement

BASH 
# Cloner le dépôt
git clone https://github.com/Shaunwei/RealChar.git
cd RealChar

# Installation des dépendances système
# macOS
brew install portaudio ffmpeg

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

# Création d'un environnement virtuel (recommandé)
python -m venv venv
source venv/bin/activate    # Linux/macOS
# venv\\Scripts\\activate   # Windows

# Installation des dépendances Python
pip install -r requirements.txt

# (Optionnel) Installation de WhisperX pour une reconnaissance vocale locale plus rapide
pip install git+https://github.com/m-bain/whisperX.git

Initialisation de la base de données

BASH 
# Création de la base de données SQLite
sqlite3 test.db "VACUUM;"

# Exécution des migrations de base de données
alembic upgrade head

Démarrage des services

BASH 
# Définition des variables d'environnement
cp .env.example .env
# Éditez le fichier .env pour y ajouter vos clés API

# Lancement du backend
python cli.py run-uvicorn
# ou directement avec uvicorn
uvicorn realtime_ai_character.main:app

# Lancement du frontend (dans une nouvelle fenêtre de terminal)
cd client/next-web
cp .env.example .env
npm install
npm run dev

L'application sera ensuite accessible à l'adresse http://localhost:3000.

Création de personnages IA personnalisés

La valeur fondamentale de RealChar réside dans sa capacité à permettre la création de personnages IA uniques. Deux méthodes sont disponibles :

Méthode 1 : Via l'interface web (aucune programmation requise)

  1. Connectez-vous à l'interface web et cliquez sur « Create Character ».
  2. Remplissez les informations du personnage : - Nom : nom du personnage - Description : brève présentation du personnage - Personnalité : description de la personnalité (par exemple : « amical, drôle, patient »). - Arrière-plan : histoire du personnage (par exemple : « chevalier médiéval ayant participé aux croisades »). - Salutation : phrase d'accroche du personnage.
  3. (Optionnel) Téléversez un avatar.
  4. Sélectionnez une voix (si vous utilisez ElevenLabs, vous pouvez cloner une voix spécifique).
  5. Cliquez sur « Sauvegarder » pour créer le personnage.

Méthode 2 : Via le code (pour les utilisateurs avancés)

Dans le répertoire realtime_ai_character/character_catalog/, créez un nouveau fichier YAML :

YAML 
# my_character.yaml
name: "Historien Aristote"
description: "Philosophe grec antique, maîtrisant la philosophie, la science et la politique"
personality: |
  Vous êtes un philosophe grec antique érudit, dont le discours est empreint de sagesse, aimant utiliser des métaphores et des histoires pour expliquer des concepts complexes.
  Vous êtes passionné par la connaissance et orientez toujours la conversation vers l'essence des questions.
arrière-plan: |
  Aristote (384–322 av. J.-C.) était un philosophe grec antique, élève de Platon et précepteur d'Alexandre le Grand.
  Ses travaux couvrent la physique, la métaphysique, l'éthique, la politique, la biologie et de nombreux autres domaines.
  Vous pensez qu'on peut comprendre l'essence du monde par l'observation et le raisonnement logique.
salutation: "Salut, jeune chercheur de savoir. Je suis Aristote, explorons ensemble les secrets de la vérité."
voix: "en-US-ChristopherNeural"   # voix Edge TTS
# ou ElevenLabs : voice_id: "votre_id_de_voix"

Après avoir enregistré le fichier, redémarrez le service backend – le personnage sera chargé automatiquement.

Enrichir un personnage avec une base de connaissances

RealChar prend en charge le RAG (Retrieval-Augmented Generation), permettant à un personnage de s'appuyer sur des connaissances spécifiques :

PYTHON 
# Ingérer des connaissances avec LlamaIndex
from llama_index import VectorStoreIndex, SimpleDirectoryReader
from realtime_ai_character.database.chroma import get_chroma

# Charger les documents
documents = SimpleDirectoryReader("knowledge_docs/").load_data()

# Créer un index vectoriel
index = VectorStoreIndex.from_documents(documents)

# Stocker dans Chroma
chroma = get_chroma()
chroma.add_character_knowledge("aristote", index)

Lorsqu'un utilisateur posera une question sur l'éthique à « Aristote », le personnage s'appuiera sur les documents fournis pour fournir une réponse précise et spécialisée, plutôt qu'une réponse générique.

Mécanisme d'interaction en temps réel

L'expérience « en temps réel » constitue le point fort majeur de RealChar. Voici le déroulement de l'interaction :

Flux d'interaction vocale

  1. L'utilisateur parle : le capteur microphone du navigateur capte l'audio.
  2. Reconnaissance vocale : l'audio est envoyé via WebSocket au backend, où Whisper/WhisperX le convertit en texte.
  3. Inférence du LLM : le texte est transmis au LLM (par exemple GPT-4), qui génère une réponse.
  4. Synthèse vocale : le texte de réponse est transformé en audio par ElevenLabs/Edge TTS.
  5. Push en temps réel : l'audio est transmis en flux via WebSocket vers le frontend pour être lu.

L'ensemble du processus prend généralement entre 1 et 3 secondes, la latence dépendant principalement de l'inférence du LLM et de la synthèse vocale.

Astuces pour réduire la latence

  • Utiliser GPT-3.5 au lieu de GPT-4 (inférence plus rapide).
  • Utiliser WhisperX local avec accélération GPU (reconnaissance vocale locale plus rapide).
  • Utiliser ElevenLabs V2 (synthèse vocale plus rapide).
  • Activer le mode streaming (RealChar le prend en charge par défaut).

Interaction textuelle

Si vous ne souhaitez pas utiliser la voix, vous pouvez saisir directement du texte dans la zone de texte : RealChar contourne alors les étapes de reconnaissance et de synthèse vocales et renvoie une réponse textuelle directe.

Cas d'utilisation

Grâce à son architecture flexible, RealChar s'adapte à de nombreux scénarios :

1. Assistant virtuel

Créez un « assistant chef de produit », alimentez-le avec de la documentation produit, des retours utilisateurs et des analyses concurrentielles. Les membres de l'équipe peuvent poser des questions par voix : « Quels étaient les principaux points de douleur dans les retours utilisateurs de la semaine dernière ? » – l'assistant répondra en s'appuyant sur sa base de connaissances.

2. Éducation en ligne

Créez un « professeur de physique Newton », importez des manuels de physique. Les élèves peuvent discuter de mécanique avec « Newton » et obtenir une expérience d'apprentissage immersive alliant histoire et physique – bien plus attrayant qu'un simple manuel.

3. Divertissement et compagnie

Créez un « comédien de stand-up drôle » doté d'un tempérament comique et d'un passé amusant. Les utilisateurs peuvent discuter pour se détendre ou même s'affronter lors de « duels comiques ».

4. Bot de service client

Pour un site e-commerce, créez un « agent de service client professionnel Xiao Wang », nourrissez-le avec des manuels produit, des politiques de retour et des FAQ. Les clients peuvent demander par voix l'état d'une commande, la procédure de retour, etc., ce qui est plus naturel qu'un service client texte traditionnel.

5. Apprentissage des langues

Créez un « professeur d'anglais Emma » incarnant une enseignante américaine patiente et amicale. Les apprenants peuvent pratiquer leur expression orale avec Emma, qui corrigera leur prononciation et prodiguera des conseils d'apprentissage.

Comparaison avec d'autres plateformes de chat IA

RealChar se distingue nettement des produits de chat IA courants :

Fonctionnalité RealChar Character.AI Chatbot simple
Open source ✅ Entièrement ouvert ❌ Fermé ❌ Fermé
Interaction vocale ✅ Voix en temps réel ❌ Uniquement texte ❌ Uniquement texte
Auto-hébergé ✅ Docker/Python ❌ Uniquement cloud ❌ Uniquement cloud
Choix du LLM ✅ Plusieurs modèles ❌ Modèle fixe ❌ Modèle fixe
Base de connaissances ✅ Support RAG ❌ Limité ❌ Limité
Clonage de voix ✅ ElevenLabs ❌ Non supporté ❌ Non supporté
Confidentialité des données ✅ Hébergement local ❌ Stockage cloud ❌ Stockage cloud
Personnalisation ✅ Hautement configurable ⚠️ Limité ⚠️ Limité

Avantages de RealChar : - Totalement ouvert : le code source peut être modifié librement pour répondre à des besoins spécifiques. - Interaction vocale en temps réel : offre une véritable expérience de « conversation » plutôt qu'un simple chat textuel. - Confidentialité des données : déploiement local, les données ne quittent jamais votre environnement. - Extensibilité : conception modulaire facilitant l'ajout de nouvelles fonctionnalités.

Inconvénients de RealChar : - Nécessite un auto-hébergement et une maintenance. - Nécessite des clés API ( pouvant engendrer des coûts ). - L'application mobile n'est actuellement disponible que pour iOS.

Feuille de route pour l'avenir

Selon la feuille de route officielle de RealChar sur GitHub, les développements à venir portent sur :

  • ✅ Gestion des sessions : prise en charge du contexte pour les conversations multi-tours.
  • ✅ Amélioration du RAG : capacités renforcées de gestion de la base de connaissances.
  • ✅ Support Agents/GPTs : intégration de capacités d'agent permettant aux personnages d'accomplir des tâches complexes.
  • ✅ Plus de services TTS : prise en charge de moteurs de synthèse vocale supplémentaires.
  • ⏳ Interaction multimodale : possibilité future d'accepter des entrées image et vidéo.
  • ⏳ Marché aux personnages : plateforme permettant le partage et le téléchargement de configurations de personnages.

La communauté est active sur Discord, où des mises à jour et des maintenances régulières sont effectuées. Le projet est diffusé sous licence MIT et encourage les contributions de tous.

Conclusion

RealChar est une plateforme open-source extrêmement prometteuse pour l'interaction en temps réel avec des personnages IA. Elle ne se contente pas de fournir une pile technologique complète permettant de créer et déployer rapidement des personnages IA ; grâce à l'interaction vocale en temps réel, elle dépasse la limitation des chats purement textuels.

Public cible : - Tous ceux qui souhaitent créer leurs propres compagnons IA personnalisés. - Les développeurs ayant besoin de fonctionnalités de personnages IA. - Les entreprises attachant de l'importance à la confidentialité des données et privilégiant le déploiement local. - Les chercheurs intéressés par les agents IA et l'interaction en temps réel.

Démarrage rapide :

BASH 
git clone https://github.com/Shaunwei/RealChar.git
cd RealChar
cp .env.example .env
# Éditez .env pour y ajouter votre clé API
docker compose up
# Accédez à http://localhost:3000

Que vous cherchiez un compagnon de discussion virtuel pour la vie quotidienne ou que vous souhaitiez développer un service client intelligent pour votre entreprise, RealChar fournit une base solide. Grâce à son caractère open-source, la communauté peut collectivement faire évoluer la plateforme et créer sans cesse de nouvelles applications impressionnantes.