Vanna.ai Tutorial: Excel-Daten lokal mit KI analysieren (SQLite + ChromaDB + Gemini)

Stell dir vor, du könntest mit deinen Excel-Daten chatten wie mit ChatGPT - und das 100% lokal auf deinem Computer! Mit Vanna.ai wird genau das möglich. In diesem Tutorial zeige ich dir, wie du deine Excel-Daten in eine SQLite-Datenbank überführst und mit einem kostenlosen Gemini API-Key per KI analysierst.

Was ist Vanna.ai?

Vanna.ai ist ein Open-Source Python-Framework für Text-to-SQL mit RAG (Retrieval Augmented Generation). Es ermöglicht:

• ✅ Natürlichsprachliche SQL-Abfragen ("Zeige mir alle Verkäufe über 1000€")
• ✅ Automatische Chart-Generierung (Plotly, Matplotlib)
• ✅ Lokale Ausführung (DSGVO-konform!)
• ✅ Integration mit LLMs (OpenAI, Gemini, Mistral, Llama)
• ✅ RAG-basiertes Training auf deinem Schema

Warum Vanna.ai + SQLite + ChromaDB + Gemini?

Diese Kombination ist perfekt für Datenschutz-bewusste Anwender:

Kosten: $0 (alles kostenlos!)

Voraussetzungen

Bevor wir starten:

• Python 3.8+ installiert
• Excel-Datei mit deinen Daten
• Gemini API-Key (kostenlos bei ai.google.dev)
• Grundlegende Python-Kenntnisse (nicht zwingend)

Schritt 1: Umgebung einrichten

1.1 Virtual Environment erstellen

# Ordner erstellen
mkdir vanna-excel-project
cd vanna-excel-project

# Virtual Environment
python -m venv venv

# Aktivieren (Linux/Mac)
source venv/bin/activate

# Aktivieren (Windows)
venv\Scripts\activate

1.2 Dependencies installieren

# Vanna.ai mit ChromaDB
pip install vanna[chromadb]

# Excel-Support
pip install pandas openpyxl

# Gemini Integration
pip install google-generativeai

# Visualization
pip install plotly matplotlib

# Optional: Jupyter Notebook
pip install jupyter

requirements.txt:

vanna[chromadb]==0.5.5
pandas==2.2.0
openpyxl==3.1.2
google-generativeai==0.3.2
plotly==5.18.0
matplotlib==3.8.2
jupyter==1.0.0

Schritt 2: Gemini API-Key besorgen

1. Gehe zu ai.google.dev
2. Klicke auf "Get API Key"
3. Erstelle ein neues Projekt (oder wähle bestehendes)
4. Kopiere den API-Key

Wichtig: Gemini ist kostenlos bis 60 Requests/Minute!

API-Key sicher speichern

# .env Datei erstellen
echo "GEMINI_API_KEY=dein-api-key-hier" > .env

# .env zu .gitignore hinzufügen
echo ".env" >> .gitignore

Schritt 3: Excel zu SQLite konvertieren

3.1 Excel-Daten laden

Beispiel Excel-Datei: verkaufsdaten.xlsx

3.2 Python-Script: excel_to_sqlite.py

import pandas as pd
import sqlite3

def excel_to_sqlite(excel_file, db_name='data.db', table_name='verkaufsdaten'):
    """
    Konvertiert Excel-Datei zu SQLite-Datenbank

    Args:
        excel_file: Pfad zur Excel-Datei
        db_name: Name der SQLite-Datenbank
        table_name: Name der Tabelle
    """
    # Excel einlesen
    df = pd.read_excel(excel_file)

    # Datentypen optimieren
    # Datum als DateTime
    if 'Datum' in df.columns:
        df['Datum'] = pd.to_datetime(df['Datum'])

    # Preise als Float (€ entfernen)
    if 'Preis' in df.columns:
        df['Preis'] = df['Preis'].str.replace('€', '').str.replace(',', '.').astype(float)

    # SQLite-Verbindung
    conn = sqlite3.connect(db_name)

    # DataFrame zu SQLite
    df.to_sql(table_name, conn, if_exists='replace', index=False)

    # Schema ausgeben
    cursor = conn.cursor()
    cursor.execute(f"PRAGMA table_info({table_name})")
    print(f"✅ Tabelle '{table_name}' erstellt mit folgenden Spalten:")
    for col in cursor.fetchall():
        print(f"  - {col[1]} ({col[2]})")

    conn.close()
    print(f"\n✅ Datenbank '{db_name}' erfolgreich erstellt!")

if __name__ == "__main__":
    excel_to_sqlite('verkaufsdaten.xlsx')

Ausführen:

python excel_to_sqlite.py

Schritt 4: Vanna.ai mit Gemini konfigurieren

4.1 Vanna initialisieren

Erstelle vanna_chatbot.py:

import os
from dotenv import load_dotenv
from vanna.chromadb import ChromaDB_VectorStore
from vanna.google import GoogleGeminiChat

# .env laden
load_dotenv()

class VannaExcelChatbot(ChromaDB_VectorStore, GoogleGeminiChat):
    def __init__(self, config=None):
        # ChromaDB für Embeddings
        ChromaDB_VectorStore.__init__(self, config=config)
        # Gemini für LLM
        GoogleGeminiChat.__init__(self, config=config)

# Vanna initialisieren
vn = VannaExcelChatbot(config={
    'api_key': os.getenv('GEMINI_API_KEY'),
    'model': 'gemini-1.5-flash',  # Schnellstes Modell
})

# SQLite-Verbindung
vn.connect_to_sqlite('data.db')

print("✅ Vanna.ai erfolgreich initialisiert!")

Schritt 5: Training - Vanna dein Schema beibringen

Vanna muss dein Datenbank-Schema lernen, um gute SQL-Abfragen zu generieren.

5.1 DDL-Training (Schema)

# Schema automatisch einlesen
ddl = vn.get_training_data()

# Training
vn.train(ddl="""
CREATE TABLE verkaufsdaten (
    Datum TEXT,
    Produkt TEXT,
    Menge INTEGER,
    Preis REAL,
    Kunde TEXT,
    Region TEXT
);
""")

print("✅ Schema trainiert!")

5.2 Beispiel-Fragen trainieren (Optional)

Für bessere Ergebnisse kannst du Beispiel-Fragen/SQL-Paare hinzufügen:

# Beispiel-Trainings-Paare
training_data = [
    {
        "question": "Zeige alle Verkäufe aus Bayern",
        "sql": "SELECT * FROM verkaufsdaten WHERE Region = 'Bayern'"
    },
    {
        "question": "Welches Produkt wurde am häufigsten verkauft?",
        "sql": "SELECT Produkt, SUM(Menge) as Gesamt FROM verkaufsdaten GROUP BY Produkt ORDER BY Gesamt DESC LIMIT 1"
    },
    {
        "question": "Gesamtumsatz pro Region",
        "sql": "SELECT Region, SUM(Preis * Menge) as Umsatz FROM verkaufsdaten GROUP BY Region"
    }
]

for item in training_data:
    vn.train(question=item['question'], sql=item['sql'])

print(f"✅ {len(training_data)} Beispiele trainiert!")

Schritt 6: Mit deinen Daten chatten!

Jetzt kommt der spannende Teil - wir chatten mit unseren Daten!

6.1 Einfache Fragen

# Frage stellen
question = "Zeige mir alle Verkäufe über 500€"

# Vanna generiert SQL
sql = vn.generate_sql(question)
print(f"📊 Generierte SQL-Query:\n{sql}\n")

# SQL ausführen
result = vn.run_sql(sql)
print("📈 Ergebnis:")
print(result)

Output:

SELECT * FROM verkaufsdaten WHERE Preis > 500

6.2 Aggregationen

question = "Welcher Kunde hat am meisten gekauft?"

sql = vn.generate_sql(question)
result = vn.run_sql(sql)
print(result)

6.3 Visualisierungen

Vanna kann automatisch Charts generieren:

question = "Zeige mir den Umsatz pro Monat als Liniendiagramm"

# Generiere SQL + Plotly-Code
sql = vn.generate_sql(question)
plotly_code = vn.generate_plotly_code(question=question, sql=sql, df=vn.run_sql(sql))

# Chart anzeigen
exec(plotly_code)  # Öffnet interaktiven Chart im Browser

Schritt 7: Web-Interface (Optional)

Vanna hat ein eingebautes Streamlit-Interface:

# Streamlit installieren
pip install streamlit

# Web-UI starten
vn.launch_streamlit()

Öffnet automatisch im Browser: http://localhost:8501

Features:

• ✅ Chat-Interface
• ✅ SQL-Anzeige
• ✅ Tabellen-Ansicht
• ✅ Chart-Generierung
• ✅ Download-Funktionen

Schritt 8: Production-Ready Setup

Für den produktiven Einsatz:

8.1 Caching aktivieren

vn = VannaExcelChatbot(config={
    'api_key': os.getenv('GEMINI_API_KEY'),
    'model': 'gemini-1.5-flash',
    'cache': True  # Aktiviert Caching
})

8.2 Error Handling

def safe_query(question):
    try:
        sql = vn.generate_sql(question)
        result = vn.run_sql(sql)
        return result
    except Exception as e:
        print(f"❌ Fehler: {e}")
        return None

# Nutzung
result = safe_query("Umsatz nach Region")

8.3 Logging

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

logger.info("SQL generiert: %s", sql)

Performance-Optimierung

1. Gemini-Modell-Wahl

Empfehlung: Flash für Echtzeit, Pro für komplexe Analysen.

2. ChromaDB-Tuning

vn = VannaExcelChatbot(config={
    'api_key': os.getenv('GEMINI_API_KEY'),
    'n_results': 10,  # Top-10 relevante Beispiele
})

3. SQLite-Indizes

Für große Datasets (>100k Zeilen):

import sqlite3

conn = sqlite3.connect('data.db')
cursor = conn.cursor()

# Index auf häufig gesuchten Spalten
cursor.execute("CREATE INDEX idx_region ON verkaufsdaten(Region)")
cursor.execute("CREATE INDEX idx_datum ON verkaufsdaten(Datum)")

conn.commit()
conn.close()

Troubleshooting

Problem 1: "API Key invalid"

# .env prüfen
cat .env

# Neu laden
source venv/bin/activate

Problem 2: Schlechte SQL-Queries

Lösung: Mehr Beispiele trainieren!

# 10-20 Beispiel-Fragen/SQL-Paare hinzufügen
vn.train(question="...", sql="...")

Problem 3: ChromaDB Error

# ChromaDB neu installieren
pip uninstall chromadb
pip install chromadb==0.4.22

Sicherheit & Datenschutz

DSGVO-Konformität

• ✅ Alle Daten lokal (SQLite auf deinem PC)
• ✅ ChromaDB lokal (keine Cloud-Uploads)
• ⚠️ Nur Fragen zu Gemini (keine Rohdaten!)

Was wird an Gemini gesendet:

• Datenbank-Schema (Spaltennamen)
• Deine Frage
• KEINE Rohdaten!

Best Practices

1. Sensitive Daten anonymisieren

   df['Kunde'] = df['Kunde'].apply(lambda x: hashlib.md5(x.encode()).hexdigest()[:8])
   

2. API-Key sicher speichern

   # NIEMALS in Git committen!
   echo ".env" >> .gitignore
   

3. Rate Limits beachten
   • Gemini Free: 60 req/min
   • Bei Überschreitung: 429 Error

Alternative LLMs (ohne API-Key)

Falls du komplett offline arbeiten willst:

1. Ollama (lokal)

# Ollama installieren
curl -fsSL https://ollama.com/install.sh | sh

# Llama 3 runterladen
ollama pull llama3

# Vanna mit Ollama
from vanna.ollama import Ollama
vn = Ollama(model='llama3')

2. LM Studio

from vanna.openai import OpenAI_Chat

vn = OpenAI_Chat(
    api_key='not-needed',
    base_url='http://localhost:1234/v1',
    model='local-model'
)

Real-World Use Cases

Use Case 1: Verkaufsanalyse

questions = [
    "Top 5 Kunden nach Umsatz",
    "Durchschnittlicher Bestellwert pro Monat",
    "Welche Produkte werden zusammen gekauft?",
    "Umsatztrend der letzten 12 Monate"
]

for q in questions:
    sql = vn.generate_sql(q)
    result = vn.run_sql(sql)
    print(f"\n📊 {q}")
    print(result.head())

Use Case 2: Automatische Reports

import schedule
import time

def daily_report():
    sql = vn.generate_sql("Umsatz von gestern")
    result = vn.run_sql(sql)
    # Per E-Mail versenden
    send_email(result.to_html())

schedule.every().day.at("08:00").do(daily_report)

while True:
    schedule.run_pending()
    time.sleep(60)

Erweiterte Features

1. Multi-Table Support

# Mehrere Excel-Sheets
sheets = pd.read_excel('data.xlsx', sheet_name=None)

for sheet_name, df in sheets.items():
    df.to_sql(sheet_name, conn, if_exists='replace', index=False)
    vn.train(ddl=f"-- Tabelle: {sheet_name}")

2. Custom Aggregationen

vn.train(
    question="Zeige mir Umsatz YTD (Year-to-Date)",
    sql="""
    SELECT SUM(Preis * Menge) as YTD_Umsatz
    FROM verkaufsdaten
    WHERE strftime('%Y', Datum) = strftime('%Y', 'now')
    """
)

Kosten-Vergleich

Gewinner: Vanna + Gemini (kostenlos & schnell!)

Fazit

Mit Vanna.ai + SQLite + ChromaDB + Gemini kannst du in 30 Minuten einen vollwertigen Daten-Chatbot bauen - 100% kostenlos und lokal!

Vorteile:

• ✅ Keine SQL-Kenntnisse nötig
• ✅ Natürlichsprachliche Abfragen
• ✅ DSGVO-konform
• ✅ Kostenlos (Gemini Free Tier)
• ✅ Automatische Visualisierungen

Einschränkungen:

• ⚠️ Gemini API-Rate-Limits (60/min)
• ⚠️ Training benötigt Beispiele
• ⚠️ Nur für strukturierte Daten (Excel/CSV)

Nächste Schritte

1. Probiere es aus! (30 Min Tutorial durcharbeiten)
2. Trainiere mehr Beispiele (bessere Accuracy)
3. Erweitere auf CSV/JSON (andere Datenquellen)
4. Baue Dashboard (Streamlit/Gradio)

Häufig gestellte Fragen (FAQs)

Funktioniert das auch mit CSV-Dateien? Ja! Einfach pd.read_csv() statt pd.read_excel() verwenden.

Kann ich mehrere Excel-Dateien kombinieren? Ja, als separate Tabellen oder mit SQL JOINs.

Wie viele Zeilen kann SQLite verarbeiten? Problemlos mehrere Millionen Zeilen (bei ausreichend RAM).

Brauche ich Internet? Nur für Gemini API-Calls. Mit Ollama geht's komplett offline!

Kann ich das in der Cloud deployen? Ja! Auf AWS Lambda, Google Cloud Run, oder Azure Functions.

Weiterführende Ressourcen:

• Vanna.ai Dokumentation
• Gemini API Docs
• SQLite Tutorial
• ChromaDB Guide

GitHub Repo (Beispiel-Code):github.com/kevinschestakow/vanna-excel-tutorial

Autor: Kevin Schestakow - Full Stack Developer & AI Solutions Architect Expertise: LLM Integration, RAG Systems, Data Engineering Letzte Aktualisierung: 15. Januar 2025