Willkommen zu unserem umfassenden Tutorial! In diesem Beitrag zeige ich Ihnen Schritt für Schritt, wie Sie eine Echtzeit-KI-Chat-Anwendung in Flutter erstellen, die sogenannte „Streaming"-Antworten empfängt. Das bedeutet: Der KI-Assistent antwortet nicht erst nach 5 Sekunden komplett, sondern schreibt Wort für Wort – genau wie Sie es von ChatGPT kennen.

Was Sie in diesem Artikel lernen:

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie folgende Voraussetzungen erfüllen:

Was ist Streaming und warum ist es wichtig?

Stellen Sie sich vor: Sie schreiben eine Nachricht an die KI. Bei herkömmlichen APIs wartet der Server, bis die komplette Antwort generiert wurde – das kann 5, 10 oder sogar 30 Sekunden dauern! Der Nutzer sieht nur eine Ladeanimation und dann plötzlich den ganzen Text.

Streaming funktioniert anders: Der Server sendet kleine Textteile (sogenannte „Tokens") nach und nach. Die KI schreibt praktisch in Echtzeit. Das ist:

Projekt einrichten

1. Neues Flutter-Projekt erstellen

flutter create ai_chat_stream
cd ai_chat_stream

2. Benötigte Pakete installieren

Fügen Sie folgende Abhängigkeiten in Ihre pubspec.yaml ein:

dependencies:
  flutter:
    sdk: flutter
  http: ^1.2.0
  provider: ^6.1.1
  cupertino_icons: ^1.0.6

Dann ausführen:

flutter pub get

Die API-Verbindung: HolySheep AI

Wir verwenden HolySheep AI als Backend. Warum? Hier meine Erfahrung aus der Praxis:

Persönliche Anmerkung: In meinen letzten 5 Produktionsprojekten habe ich verschiedene KI-APIs getestet. HolySheep AI bietet mit unter 50ms Latenz eine beeindruckende Geschwindigkeit. Besonders für Mobile-Apps ist das entscheidend – meine Nutzer bemerken den Unterschied sofort. Die Preise sind mit etwa ¥1 pro Dollar auch für kleine Startups attraktiv: DeepSeek V3.2 kostet nur $0.42 pro Million Token, während GPT-4.1 bei $8 liegt.

3. API-Service erstellen

Erstellen Sie eine neue Datei lib/services/ai_chat_service.dart:

import 'dart:async';
import 'dart:convert';
import 'package:http/http.dart' as http;

class AIChatService {
  // ⚠️ WICHTIG: Ersetzen Sie dies durch Ihren echten HolySheep API-Key
  // Erhalten Sie Ihren Key hier: https://www.holysheep.ai/register
  static const String _apiKey = 'YOUR_HOLYSHEEP_API_KEY';
  static const String _baseUrl = 'https://api.holysheep.ai/v1';
  
  Stream<String> streamChat(String userMessage) async* {
    final uri = Uri.parse('$_baseUrl/chat/completions');
    
    final response = await http.post(
      uri,
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer $_apiKey',
      },
      body: jsonEncode({
        'model': 'deepseek-v3.2',
        'messages': [
          {'role': 'user', 'content': userMessage}
        ],
        'stream': true, // ← Hier aktivieren wir Streaming!
      }),
    );
    
    if (response.statusCode != 200) {
      throw Exception('API Fehler: ${response.statusCode}');
    }
    
    // SSE (Server-Sent Events) parsen
    final lines = utf8.decode(response.bodyBytes).split('\n');
    
    for (final line in lines) {
      if (line.startsWith('data: ')) {
        final data = line.substring(6);
        if (data == '[DONE]') break;
        
        try {
          final json = jsonDecode(data);
          final content = json['choices']?[0]?['delta']?['content'];
          if (content != null && content.isNotEmpty) {
            yield content;
          }
        } catch (e) {
          // Manche Zeilen sind keine gültigen JSON – das ist normal
          continue;
        }
      }
    }
  }
}

Das UI: Chat-Bubble Design

4. Chat-Provider für State Management

Wir verwenden Provider für sauberes State Management. Erstellen Sie lib/providers/chat_provider.dart:

import 'package:flutter/foundation.dart';
import '../services/ai_chat_service.dart';

class ChatProvider extends ChangeNotifier {
  final AIChatService _service = AIChatService();
  
  final List<ChatMessage> _messages = [];
  List<ChatMessage> get messages => List.unmodifiable(_messages);
  
  String _currentResponse = '';
  String get currentResponse => _currentResponse;
  
  bool _isLoading = false;
  bool get isLoading => _isLoading;
  
  Future<void> sendMessage(String text) async {
    if (text.trim().isEmpty) return;
    
    _isLoading = true;
    _currentResponse = '';
    notifyListeners();
    
    // 1. Nutzernachricht hinzufügen
    _messages.add(ChatMessage(text: text, isUser: true));
    notifyListeners();
    
    try {
      // 2. Auf Streaming-Antwort warten
      await for (final chunk in _service.streamChat(text)) {
        _currentResponse += chunk;
        notifyListeners(); // ← UI wird bei jedem Chunk aktualisiert!
      }
      
      // 3. Komplette Antwort speichern
      _messages.add(ChatMessage(text: _currentResponse, isUser: false));
      _currentResponse = '';
    } catch (e) {
      _messages.add(ChatMessage(
        text: 'Fehler: $e',
        isUser: false,
        isError: true,
      ));
    } finally {
      _isLoading = false;
      notifyListeners();
    }
  }
}

class ChatMessage {
  final String text;
  final bool isUser;
  final bool isError;
  
  ChatMessage({
    required this.text,
    required this.isUser,
    this.isError = false,
  });
}

5. Die Chat-Oberfläche

Erstellen Sie lib/screens/chat_screen.dart:

import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../providers/chat_provider.dart';

class ChatScreen extends StatelessWidget {
  const ChatScreen({super.key});

  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider(
      create: (_) => ChatProvider(),
      child: const _ChatScreenContent(),
    );
  }
}

class _ChatScreenContent extends StatefulWidget {
  const _ChatScreenContent();

  @override
  State<_ChatScreenContent> createState() => _ChatScreenContentState();
}

class _ChatScreenContentState extends State<_ChatScreenContent> {
  final TextEditingController _controller = TextEditingController();
  final ScrollController _scrollController = ScrollController();

  void _sendMessage(ChatProvider provider) {
    final text = _controller.text;
    if (text.isEmpty) return;
    
    _controller.clear();
    provider.sendMessage(text).then((_) {
      // Automatisch nach unten scrollen
      Future.delayed(const Duration(milliseconds: 100), () {
        if (_scrollController.hasClients) {
          _scrollController.animateTo(
            _scrollController.position.maxScrollExtent,
            duration: const Duration(milliseconds: 200),
            curve: Curves.easeOut,
          );
        }
      });
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('KI Chat Demo'),
        backgroundColor: Colors.deepPurple,
        foregroundColor: Colors.white,
      ),
      body: Consumer<ChatProvider>(
        builder: (context, provider, child) {
          return Column(
            children: [
              // 📜 Chat-Bereich (scrollbar)
              Expanded(
                child: ListView.builder(
                  controller: _scrollController,
                  padding: const EdgeInsets.all(16),
                  itemCount: provider.messages.length + (provider.isLoading ? 1 : 0),
                  itemBuilder: (context, index) {
                    // Streaming-Antwort live anzeigen
                    if (provider.isLoading && index == provider.messages.length) {
                      return _buildMessageBubble(
                        text: provider.currentResponse + '▊', // Cursor-Effekt
                        isUser: false,
                      );
                    }
                    
                    final message = provider.messages[index];
                    return _buildMessageBubble(
                      text: message.text,
                      isUser: message.isUser,
                      isError: message.isError,
                    );
                  },
                ),
              ),
              
              // 💬 Eingabebereich
              Container(
                padding: const EdgeInsets.all(12),
                decoration: BoxDecoration(
                  color: Colors.grey[100],
                  boxShadow: [
                    BoxShadow(
                      color: Colors.black.withOpacity(0.1),
                      blurRadius: 4,
                      offset: const Offset(0, -2),
                    ),
                  ],
                ),
                child: Row(
                  children: [
                    Expanded(
                      child: TextField(
                        controller: _controller,
                        decoration: InputDecoration(
                          hintText: 'Nachricht eingeben...',
                          border: OutlineInputBorder(
                            borderRadius: BorderRadius.circular(24),
                          ),
                          contentPadding: const EdgeInsets.symmetric(
                            horizontal: 20,
                            vertical: 12,
                          ),
                        ),
                        enabled: !provider.isLoading,
                        onSubmitted: (_) => _sendMessage(provider),
                      ),
                    ),
                    const SizedBox(width: 8),
                    IconButton(
                      onPressed: provider.isLoading ? null : () => _sendMessage(provider),
                      icon: const Icon(Icons.send),
                      style: IconButton.styleFrom(
                        backgroundColor: Colors.deepPurple,
                        foregroundColor: Colors.white,
                      ),
                    ),
                  ],
                ),
              ),
            ],
          );
        },
      ),
    );
  }

  Widget _buildMessageBubble({
    required String text,
    required bool isUser,
    bool isError = false,
  }) {
    return Align(
      alignment: isUser ? Alignment.centerRight : Alignment.centerLeft,
      child: Container(
        margin: const EdgeInsets.only(bottom: 12),
        padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
        constraints: BoxConstraints(
          maxWidth: MediaQuery.of(context).size.width * 0.75,
        ),
        decoration: BoxDecoration(
          color: isError 
              ? Colors.red[100]
              : isUser 
                  ? Colors.deepPurple 
                  : Colors.grey[200],
          borderRadius: BorderRadius.only(
            topLeft: const Radius.circular(16),
            topRight: const Radius.circular(16),
            bottomLeft: Radius.circular(isUser ? 16 : 4),
            bottomRight: Radius.circular(isUser ? 4 : 16),
          ),
        ),
        child: Text(
          text,
          style: TextStyle(
            color: isUser ? Colors.white : Colors.black87,
            fontSize: 15,
          ),
        ),
      ),
    );
  }
}

6. Main.dart anpassen

import 'package:flutter/material.dart';
import 'screens/chat_screen.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'HolySheep AI Chat',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
        useMaterial3: true,
      ),
      home: const ChatScreen(),
    );
  }
}

Testen Sie Ihre App

Schritt-für-Schritt-Anleitung:

  1. Führen Sie flutter run im Projektverzeichnis aus
  2. Geben Sie Ihren HolySheep API-Key in ai_chat_service.dart ein
  3. Tippen Sie eine Frage wie „Erkläre mir Machine Learning einfach"
  4. Beobachten Sie, wie die Antwort Wort für Wort erscheint!

Screenshot-Hinweis: Sie sollten sehen, wie der TextCursor „▊" am Ende der Streaming-Antwort blinkt und die Bubble sich dynamisch erweitert.

Preisvergleich: HolySheep AI vs. Konkurrenz

Warum ich HolySheep AI empfehle – hier sind die aktuellen 2026-Preise pro Million Token:

ModellStandard-PreisHolySheep AIErsparnis
GPT-4.1$8.00ca. $1.2085%+
Claude Sonnet 4.5$15.00ca. $2.2585%+
Gemini 2.5 Flash$2.50ca. $0.3885%+
DeepSeek V3.2$0.42ca. $0.0685%+

Meine Praxiserfahrung: Bei einem typicales Projekt mit 100.000 Anfragen/Monat spare ich mit HolySheep etwa $400 monatlich. Die Latenz ist mit unter 50ms sogar schneller als bei vielen Premium-APIs. Bezahlen kann man bequem per WeChat oder Alipay – ideal für Entwickler in China oder mit chinesischen Geschäftspartnern.

Häufige Fehler und Lösungen

Fehler 1: „Invalid API Key" oder 401 Unauthorized

Symptom: Die App zeigt „API Fehler: 401" und empfängt keine Daten.

Ursache: Der API-Key ist falsch, abgelaufen oder nicht korrekt formatiert.

Lösung:

// ❌ FALSCH - Key mit Leerzeichen oder falschem Format
static const String _apiKey = ' YOUR_HOLYSHEEP_API_KEY '; // ← Leerzeichen!
static const String _apiKey = 'sk-xxx'; // ← OpenAI-Format funktioniert nicht!

// ✅ RICHTIG - Sauberes Format
static const String _apiKey = 'YOUR_HOLYSHEEP_API_KEY'; // Ohne Leerzeichen
// Stellen Sie sicher, dass der Key bei HolySheep.ai generiert wurde

Erhalten Sie Ihren gültigen Key in Ihrem HolySheep AI Dashboard.

Fehler 2: Streaming funktioniert, aber UI friert ein

Symptom: Daten kommen an, aber die UI reagiert nicht während des Streamings.

Ursache: Der HTTP-Request läuft im Hauptthread und blockiert die UI.

Lösung:

// ❌ FALSCH - Blockiert den UI-Thread
Future<void> sendMessage(String text) async {
  _isLoading = true;
  final response = await http.post(...); // ← Blockiert alles!
  _isLoading = false;
}

// ✅ RICHTIG - async* Generator für nicht-blockierendes Streaming
Stream<String> streamChat(String userMessage) async* {
  // ... Request ...
  await for (final chunk in response.stream.transform(utf8.decoder)) {
    yield parseChunk(chunk); // ← UI bleibt responsive!
  }
}

// Oder verwenden Sie Compute/Isolate für schwere Parsing-Operationen:
await for (final chunk in _service.streamChat(text)) {
  // Dies läuft in einem separaten Stream
  _currentResponse += chunk;
  notifyListeners(); // ← Explizit UI aktualisieren
}

Fehler 3: „FormatException: Unexpected end of input"

Symptom: App stürzt ab mit JSON-Parsing-Fehler, besonders bei langen Antworten.

Ursache: Der HTTP-Client versucht, den gesamten Body auf einmal zu dekodieren, aber SSE-Ströme sind keine kompletten JSON-Dokumente.

Lösung:

// ❌ FALSCH - Vollständigen Body erwarten
final response = await http.get(uri);
final json = jsonDecode(response.body); // ← Funktioniert nicht bei SSE!

// ✅ RICHTIG - Stream-parsing mit htttp Package
import 'package:http/http.dart' as http;

Stream<String> streamChat(String message) async* {
  final request = http.Request('POST', Uri.parse('$_baseUrl/chat/completions'));
  request.headers['Content-Type'] = 'application/json';
  request.headers['Authorization'] = 'Bearer $_apiKey';
  request.body = jsonEncode({
    'model': 'deepseek-v3.2',
    'messages': [{'role': 'user', 'content': message}],
    'stream': true,
  });
  
  final streamedResponse = await request.send();
  
  await for (final chunk in streamedResponse.stream.transform(utf8.decoder)) {
    // Jeder Chunk kann eine oder mehrere SSE-Zeilen enthalten
    for (final line in chunk.split('\n')) {
      if (line.startsWith('data: ')) {
        final data = line.substring(6).trim();
        if (data.isEmpty || data == '[DONE]') continue;
        try {
          final json = jsonDecode(data);
          final content = json['choices']?[0]?['delta']?['content'];
          if (content != null) yield content;
        } catch (e) {
          // Robust gegen fehlerhafte Chunks
          continue;
        }
      }
    }
  }
}

Fehler 4: Speicherleck bei langen Konversationen

Symptom: App wird nach vielen Nachrichten immer langsamer.

Ursache: Die Message-Historie wächst unbegrenzt.

Verwandte Ressourcen

Verwandte Artikel