Fincept Terminal – Einstieg: Eine Open-Source-Plattform für Quant Trading aus einer Hand

Fincept Terminal ist ein Open-Source-Quant-Finanzterminal, das von der Fincept Corporation entwickelt wurde. Die Kernidee ist dabei sehr klar: Mit einem kostenlosen Open-Source-Tool das Bloomberg-Terminal ersetzen, das sonst schnell zehntausende Euro/Jahr kostet – und gleichzeitig es auch normalen Entwicklern ermöglichen, ihr eigenes Quant-Trading-System aufzubauen.

Es basiert auf nativem C++20 + Qt6 und liefert eine deutlich höhere Performance als Electron/Web-Anwendungen; um Größenordnungen schneller. Eingebettete Python-Module bieten vollständige Analysefähigkeiten auf CFA-Niveau. 37 KI-Agenten decken eine Vielzahl von Frameworks ab – vom Value Investing bis hin zu geopolitischen Themen. 100+ Daten-Connectoren erfassen sämtliche Quellen, von staatlichen Wirtschaftsdaten bis hin zu Kryptowährungen. Das GitHub-Repository wird unter Fincept-Corporation/FinceptTerminal gehostet und steht unter der Open-Source-Lizenz AGPL-3.0.

---

Schwierigkeitsgrad/Dauer/Ergebnis

Einsteigerfreundlich | ca. 30 Minuten | Du lernst den vollständigen Ablauf, um auf Windows / macOS / Linux von der Installation bis zum Laufen des ersten KI-Quant-Strategie-Setups zu kommen.

---

Zielgruppe

• Entwickler mit 1–4 Jahren Erfahrung, die ihr eigenes Quant-Trading-System aufbauen möchten
• Interesse an Analyse von Finanzdaten und KI-gestütztem Investment, aber ohne fachlichen Finanzhintergrund
• Suchen ein kostenloses Open-Source-Tool als Ersatz für teure Bloomberg-Terminal-Funktionen (Jahresgebühren von mehreren Tausend bis zu mehreren Zehntausend Euro)

---

Wichtige Abhängigkeiten & Umgebung

Systemanforderungen

---

Vollständige Projekt-Struktur (Tree)

FinceptTerminal/
├── fincept-qt/                 # C++-Hauptanwendung
│   ├── src/                   # C++-Kernquellcode
│   │   ├── core/             # Kernmodule
│   │   ├── ui/               # Qt-UI-Komponenten
│   │   └── python/           # Python-Binding-Schicht
│   ├── scripts/              # Build-Skripte
│   ├── CMakeLists.txt        # C++-Build-Konfiguration
│   └── CMakePresets.json     # Cross-Plattform Build-Presets (wichtig)
├── docs/                      # Entwicklung-Dokumentation
├── Dockerfile                 # Docker-Image-Konfiguration
├── setup.sh                  # Linux/macOS One-Click-Build-Skript
└── funding.json              # Community-Sponsoring-Konfiguration

---

Schritt-für-Schritt-Anleitung

Schritt 1: Fincept Terminal herunterladen und installieren

Das Projekt bietet drei Installationsmöglichkeiten – wähle die Lösung, die am besten zu dir passt.

Variante A: Vorab kompilierte Installationspakete herunterladen (empfohlen, ideal für Einsteiger)

Aktuellste Version: v4.0.2. Öffne Releases und lade das passende Paket für deine Plattform herunter:

# Windows x64
# Lade FinceptTerminal-4.0.2-win64-setup.exe herunter und starte das Installationsprogramm per Doppelklick

# Linux x64
# Lade FinceptTerminal-4.0.2-linux-x64-setup.run herunter
chmod +x FinceptTerminal-4.0.2-linux-x64-setup.run
./FinceptTerminal-4.0.2-linux-x64-setup.run

# macOS Apple Silicon (M1/M2/M3)
# Lade FinceptTerminal-4.0.2-macOS-setup.dmg herunter
# Öffne die DMG-Datei und ziehe die App in den Ordner Applications

Nach der Installation kannst du das Terminal über die Konsole starten:

# Windows
FinceptTerminal.exe

# Linux
./FinceptTerminal

# macOS
open /Applications/FinceptTerminal.app

Variante B: Docker-Deployment (für Server-Umgebungen geeignet)

# Offizielles Image ziehen
docker pull ghcr.io/fincept-corporation/fincept-terminal:latest

# Ausführen (X Server-Unterstützung für die GUI erforderlich)
docker run --rm \
    -e DISPLAY=$DISPLAY \
    -v /tmp/.X11-unix:/tmp/.X11-unix \
    ghcr.io/fincept-corporation/fincept-terminal:latest

Variante C: Quellcode klonen und per One-Click bauen (für Linux/macOS-Entwickler geeignet)

Nachdem du das Repository geklont hast, starte einfach das setup.sh-Skript. Es erkennt automatisch deine Umgebung, lädt Abhängigkeiten herunter und führt den Build aus:

git clone https://github.com/Fincept-Corporation/FinceptTerminal.git
cd FinceptTerminal
chmod +x setup.sh && ./setup.sh

Das Skript übernimmt automatisch die Installation und Konfiguration von CMake, Qt6 und Python. Nach Abschluss startet Fincept Terminal automatisch.

Schritt 2: LLM-API konfigurieren (damit KI-Agenten wirklich arbeiten)

Nach dem Start von Fincept Terminal müssen die KI-Agenten mit einem Large Language Model verbunden sein, um auszuführen zu können. Gehe zu Settings → AI Providers:

1. Wähle den AI Provider aus, den du nutzen möchtest. Das Projekt unterstützt die folgenden Optionen:

OpenAI       → GPT-4o / o1 / GPT-4.5
Anthropic    → Claude 3.5 / 3.7
Google       → Gemini 1.5 / 2.0 / 2.5
Groq         → Hochgeschwindigkeits-Inferenz
DeepSeek     → Starkes Preis-Leistungs-Verhältnis
MiniMax      → Bequem für Nutzer in China
OpenRouter   → Aggregation mehrerer Modelle
Ollama       → Lokale Modelle (vollständig offline)

1. Trage den passenden API Key ein. Wenn du ein lokales Ollama hast, kannst du komplett offline laufen:

# Wenn du Ollama auswählst (lokales Modell, kein API Key erforderlich)
# Installiere und starte Ollama zuerst lokal
ollama pull llama3.2
ollama serve

# Dann in Fincept Terminal konfigurieren:
# Provider: Ollama
# Base URL: http://localhost:11434
# Model: llama3.2

Schritt 3: Datenquellen anbinden

Fincept Terminal bietet 100+ Daten-Connectoren – von Makroökonomie bis Kryptowährungen. Gehe zu Data Sources und wähle die Datenquellen aus, die du aktivieren möchtest:

Kostenlose Datenquellen (einfach direkt nutzbar):

# Makroökonomie
DBnomics          → Globale makroökonomische Zeitreihendaten
FRED              → Wirtschaftsdaten der US-Notenbank (Fed)
IMF              → Daten des Internationalen Währungsfonds
World Bank       → Entwicklungsindikatoren der Weltbank

# Aktien & Kryptowährungen
Yahoo Finance    → Historische Kursdaten, Live-Quotes
Kraken           → Live-Kursdaten via WebSocket für Kryptowährungen
Polygon          → Daten für US-Aktien (kostenlose Stufe ist begrenzt)

# Sonstiges
AkShare          → Daten für den chinesischen A-Aktien-/Futures-Markt (Python-Bibliothek)
government APIs  → Öffentliche Datensätze von Regierungen verschiedener Länder

Allgemeine Schritte zum Verbinden von Datenquellen:

1. Öffne Data Sources → Add Connection
2. Wähle den Typ der Datenquelle (z. B. „Stock Market Data“)
3. Trage den API Key ein (bei manchen Datenquellen erforderlich) oder lasse den Standardwert unverändert (öffentliche Daten)
4. Klicke auf Test Connection, um die Verbindung zu verifizieren
5. Nach Bestätigung synchronisiert das System die Daten automatisch mit dem Terminal

Schritt 4: AI-Agenten erstellen und die erste Quant-Aufgabe ausführen

Fincept Terminal enthält 37 KI-Agenten, aufgeteilt in drei große Kategorien:

Trader / Investor-Agenten (Value-Investing-Perspektive):

Economic-Agenten: Analyse makroökonomischer Daten, Zinsprognosen, Inflationsmodellierung

Geopolitics-Agenten: Bewertung geopolitischer Auswirkungen, Analyse von Lieferkettenrisiken

Lass uns mit dem Buffett-Agenten unsere erste Aufgabe erledigen – den Wert einer Aktie analysieren:

1. Gehe zu AI Agents → Create New Agent
2. Wähle Buffett als Basis-Template
3. Gib ihm die Aufgabe: Analysiere den inneren Wert von Apple (AAPL)

Analyze the intrinsic value of AAPL using DCF model.
Use the latest financial data from Yahoo Finance.
Show the margin of safety based on current price.

Der Buffett-Agent greift auf das Python-Analyse-Modul zu, um Finanzdaten zu holen, führt ein DCF (Discounted Cash Flow)-Modell aus und gibt eine Schätzung des inneren Werts sowie die Sicherheitsmarge im Verhältnis zum aktuellen Kurs aus.

Schritt 5: Mit dem Node-Editor eine Quant-Pipeline aufbauen

Der Node-Editor ist eine der stärksten Funktionen von Fincept Terminal: Du setzt Datenquellen, Analyse-Module und KI-Agenten visuell zusammen und baust damit komplexe Quant-Pipelines – ohne auch nur eine Zeile Code zu schreiben.

Öffne die Seite Node Editor. Du siehst einen Workflow ähnlich dem Folgenden:

[Yahoo Finance Daten] → [Python Datenbereinigung] → [AI Agent Entscheidung] → [Broker Order-Ausführung]
     ↑                                              ↓
  [FRED Makro-Daten]                               [Ergebnis in Portfolio]

Ersten Quant-Workflow erstellen:

1. Ziehe links aus dem Panel einen Data Source-Node hinein und wähle Yahoo Finance
2. Ziehe einen Filter-Node hinein und konfiguriere die Filterbedingungen (z. B. „PE < 15, Market Cap > 10B“)
3. Ziehe einen Buffett Agent-Node hinein und verbinde ihn mit dem Output des Filters
4. Ziehe einen Backtest-Node hinein, um die historische Performance der Strategie zu prüfen
5. Klicke Run, um den Workflow auszuführen

Schritt 6 (optional): Aus dem Quellcode manuell kompilieren

Wenn du stärker anpassen willst oder auf der Plattform keine vorab kompilierten Pakete verfügbar sind, kannst du aus dem Quellcode bauen. Dafür ist eine präzise Konfiguration der Abhängigkeiten erforderlich.

Umgebung vorbereiten (Beispiel: Windows):

# 1. Visual Studio 2022 installieren (inkl. MSVC 19.38)
# 2. CMake 3.27.7 installieren und zu PATH hinzufügen
# 3. Ninja 1.11.1 installieren und zu PATH hinzufügen
# 4. Qt 6.8.3 installieren (im Online-Installer Qt 6.8.3 > MSVC 2022 64-bit auswählen)
#    Installationspfad z. B. auf C:/Qt/6.8.3/msvc2022_64 setzen
# 5. Python 3.11.9 installieren und zu PATH hinzufügen

Kompilieren (mit CMake Presets):

git clone https://github.com/Fincept-Corporation/FinceptTerminal.git
cd FinceptTerminal/fincept-qt

# Einmalige Konfiguration (danach muss man vor Änderungen an CMakeLists.txt neu laufen)
cmake --preset win-release

# Nach jeder Änderung am Code neu kompilieren
cmake --build --preset win-release

# Ausführen
.\build\win-release\FinceptTerminal.exe

Wenn CMake Qt nicht findet, kann es daran liegen, dass der Installationspfad abweicht – dann den manuellen Modus verwenden:

cmake -B build/win-release -G Ninja -DCMAKE_BUILD_TYPE=Release `
  -DCMAKE_PREFIX_PATH="C:/Qt/6.8.3/msvc2022_64"
cmake --build build/win-release

---

Häufige Probleme beheben

Q1: CMake meldet Fehler „Could not find Qt6 6.8.3“

Symptom: cmake --preset win-release gibt Could not find Qt6 6.8.3 aus.

Ursache: Der Qt-Installationspfad passt nicht zum CMake-Standard-Suchpfad.

Lösung:

1. Prüfe, ob im Qt-Installationspfad ein Ordner lib/cmake/Qt6 existiert
2. Pfad manuell angeben:

cmake -B build/win-release -G Ninja -DCMAKE_BUILD_TYPE=Release `
  -DCMAKE_PREFIX_PATH="C:/Qt/6.8.3/msvc2022_64"

1. Wenn du mit einer anderen Qt-Version testest, kannst du die Versionsprüfung umgehen, indem du -DFINCEPT_ALLOW_QT_DRIFT=ON setzt (nur für lokales Testen; nicht in CI oder Release-Versionen verwenden)

Q2: MSVC-Version inkompatibel

Symptom: C++ compiler version not supported oder während des Builds viele Fehler wegen nicht definierter Bezeichner.

Ursache: Das Projekt verlangt MSVC 19.38+ (entspricht Visual Studio 2022 17.8+).

Lösung:

# MSVC-Version prüfen
cl /?

# Falls zu niedrig, auf die neueste VS 2022 Version aktualisieren
# Download: https://visualstudio.microsoft.com/downloads/

Q3: Python-Version stimmt nicht überein

Symptom: Absturz nach dem Einbetten von Python oder Fehler „python3.x.x not found“.

Ursache: Das Projekt erzwingt Python 3.11.9; andere Versionen (einschließlich 3.10 und 3.12) werden nicht unterstützt.

Lösung:

# Aktuelle Python-Version prüfen
python --version

# Wenn nicht 3.11.9, installiere die richtige Version
#Download: https://www.python.org/downloads/release/python-3119/

# Windows: Nach der Installation in PATH sicherstellen, dass der Pfad zu Python 3.11.9 vorne steht
# Linux: optional mit pyenv:
pyenv install 3.11.9
pyenv local 3.11.9

Q4: Qt-GUI lässt sich in Docker nicht anzeigen

Symptom: Fehler „QPA platform: cannot connect to X server“.

Ursache: Im Docker-Container gibt es keine grafische Umgebung.

Lösung:

# Linux: Docker erlauben, den lokalen X Server zu nutzen
xhost +local:docker
docker run --rm \
    -e DISPLAY=unix$DISPLAY \
    -v /tmp/.X11-unix:/tmp/.X11-unix \
    ghcr.io/fincept-corporation/fincept-terminal:latest

Q5: KI-Agent zeigt „Connection Failed“

Symptom: Der LLM-Aufruf liefert einen Fehler zurück, der Agent kann keine Aufgaben ausführen.

Troubleshooting:

1. Prüfe, ob der API Key gültig ist (zum Beispiel den Key auf der jeweiligen offiziellen Seite testen)
2. Wenn du Ollama nutzt, stelle sicher, dass ollama serve läuft
3. Wenn du einen Proxy (Firmen-Netzwerk) nutzt, konfiguriere die HTTP-Proxy-Umgebungsvariablen:

# Linux/macOS
export HTTP_PROXY=http://your-proxy:8080
export HTTPS_PROXY=http://your-proxy:8080

# Windows PowerShell
$env:HTTP_PROXY="http://your-proxy:8080"
$env:HTTPS_PROXY="http://your-proxy:8080"

1. Prüfe, ob das Netzwerk auf die API-Endpunkte des AI Providers zugreifen kann:

# OpenAI
curl https://api.openai.com/v1/models

# Anthropic
curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: YOUR_KEY" \
    -H "anthropic-version: 2023-06-01"

Q6: Authentifizierung bei Broker-Verbindung fehlgeschlagen (Paper Trading / Live)

Symptom: Nach der Konfiguration des Broker-API wird Authentifizierung als fehlgeschlagen gemeldet.

Lösung:

1. Stelle sicher, dass du in Fincept Terminal den API Key eingetragen hast und nicht das Passwort des Trading-Accounts
2. Einige Broker (z. B. IBKR) benötigen, dass du in Trader Workstation (TWS) den Zugriff über die API aktivierst
3. Paper Trading und Live haben unterschiedliche API-Konfigurationen – prüfe, ob du den richtigen Modus gewählt hast

---

Weiterführende Lektüre / Fortgeschrittene Richtung

Adanos Market Sentiment anbinden, um Sentiment zu quantifizieren

Adanos führt Stimmungsdaten von Reddit, X/Twitter, Finanznachrichten und Polymarket in Fincept Terminal ein. Gehe zu Data Sources → Alternative Data → Adanos, konfiguriere die API und das Equity-Research-Modul zeigt anschließend Momentaufnahmen der Retail-Stimmung, aggregiert über verschiedene Quellen hinweg. Du kannst Sentiment-Indikatoren als Faktoren in Quant-Strategien einbinden und sie mit klassischen Finanzdaten kombinieren, um eine umfassendere Analyse zu erhalten.

QuantLib Suite nutzen, um Derivate zu bewerten

Fincept Terminal enthält 18 QuantLib-Quant-Module, die abdecken:

# Bewertungsmodelle
Black-Scholes-Optionspreisbewertung
Binomial Tree für amerikanische Optionen
Monte-Carlo-Bewertung

# Risikomanagement
VaR (Value at Risk)-Berechnung
 Greeks Sensitivitätsanalyse
Stresstests / Szenarioanalyse

# Festverzinsliche Produkte
Yield Curve Konstruktion
Duration / Convexity Analyse
Bond Portfolio Optimization

Über die AI Quant Lab-Oberfläche kannst du diese Module nutzen, um eigene Risikomodelle aufzubauen – ohne manuell Python-Code schreiben zu müssen.

Mehrere Broker konfigurieren, um programmatisches Trading umzusetzen

Fincept Terminal unterstützt die API-Integration von 16 Brokern und deckt ab: Aktien, Futures und Kryptowährungen.

Indische Broker: Zerodha, Angel One, Upstox, Fyers, Dhan, Groww, Kotak,
         IIFL, 5paisa, AliceBlue, Shoonya, Motilal
US-Broker: IBKR, Alpaca, Tradier
Internationale Broker: Saxo
Kryptowährungen: Kraken, HyperLiquid (WebSocket-Live-Quotes)

Du kannst gleichzeitig mehrere Broker anbinden und im Node-Editor übergreifende Arbitrage-Strategien über Märkte hinweg aufbauen.

AI Quant Lab: ML-Modelle trainieren und Faktoren entdecken

Das AI Quant Lab-Modul von Fincept Terminal bietet einen vollständigen Machine-Learning-Quant-Workflow:

# Verwendung der Python-Module
from fincept_ml import FactorDiscovery, ModelTrainer

# Effektive Faktoren automatisch aus Marktdaten entdecken
factors = FactorDiscovery.run(data_source="yahoo_finance",
                              target="AAPL_returns",
                              n_factors=20)

# Reinforcement-Learning-Trading-Strategie trainieren
strategy = ModelTrainer.train_rl(
    agent="PPO",
    environment="crypto_portfolio",
    episodes=1000
)

Außerdem unterstützt es überwachte Lernverfahren (HFT-Strategien), Zeitreihenprognosen und ein Backtesting-Framework.

An Open-Source-Entwicklung teilnehmen

Fincept Terminal ist ein Open-Source-Projekt. Beiträge zum Code sind herzlich willkommen:

• C++-Module: Qt-UI-Komponenten, Daten-Connectoren, QuantLib-Wrapper
• Python-Module: neue Analysemodelle, Machine-Learning-Strategien
• KI-Agenten: neue Investment-Framework-Agenten, Module zur Geopolitik-Analyse
• Dokumentation: Anleitungen zur Anbindung aller Funktionen verbessern

Beitragsrichtlinien: docs/CONTRIBUTING.md C++-Entwicklungsstandards: fincept-qt/CONTRIBUTING.md