Guía de inicio de Fincept Terminal: plataforma integral de trading cuantitativo de código abierto

Fincept Terminal es un terminal de finanzas cuantitativas de código abierto, desarrollado por Fincept Corporation. Su enfoque es muy claro: reemplazar el terminal de Bloomberg—que cuesta desde decenas de miles hasta miles/año—por una herramienta gratuita de código abierto, y al mismo tiempo permitir que desarrolladores comunes monten su propio sistema de trading cuantitativo.

Está construido con C++20 nativo + Qt6; su rendimiento supera en varios órdenes a las aplicaciones Electron/Web. Los módulos integrados de Python ofrecen capacidades completas de análisis de nivel CFA. Hay 37 agentes de IA que cubren múltiples marcos, desde inversión en valor hasta geopolítica. Además, 100+ conectores de datos abarcan todas las fuentes, desde indicadores económicos de gobiernos hasta criptomonedas. El repositorio de GitHub se gestiona en Fincept-Corporation/FinceptTerminal, bajo la licencia de código abierto AGPL-3.0.

---

Dificultad / Duración / Beneficios

Inicial | ~30 minutos | Aprenderás el flujo completo para instalar y ejecutar tu primera estrategia cuantitativa de IA en Windows / macOS / Linux.

---

Público objetivo

• Desarrolladores con 1-4 años de experiencia que quieran montar su propio sistema de trading cuantitativo
• Personas interesadas en el análisis de datos financieros y en inversiones asistidas por IA, pero sin formación profesional en finanzas
• Quienes buscan una herramienta gratuita de código abierto que reemplace funciones del caro terminal de Bloomberg (cuotas anuales desde miles hasta decenas de miles de dólares)

---

Dependencias principales y entorno

Requisitos del sistema

---

Estructura completa del proyecto

FinceptTerminal/
├── fincept-qt/                 # Aplicación principal en C++
│   ├── src/                   # Código fuente central en C++
│   │   ├── core/             # Módulos del núcleo
│   │   ├── ui/               # Componentes de UI de Qt
│   │   └── python/           # Capa de bindings en Python
│   ├── scripts/              # Scripts de build
│   ├── CMakeLists.txt        # Configuración de build en C++
│   └── CMakePresets.json     # Presets de compilación multiplataforma (importante)
├── docs/                      # Documentación de desarrollo
├── Dockerfile                 # Configuración de imagen Docker
├── setup.sh                  # Script de build automático para Linux/macOS
└── funding.json              # Configuración de patrocinio de la comunidad

---

Pasos paso a paso

Paso 1: Descarga e instala Fincept Terminal

El proyecto ofrece tres formas de instalación; elige la que mejor se adapte a tu caso.

Opción A: Paquete precompilado (recomendada; ideal para principiantes)

La versión más reciente actual es v4.0.2. Accede a Releases y descarga la versión correspondiente a tu plataforma:

# Windows x64
# Descarga FinceptTerminal-4.0.2-win64-setup.exe y ejecuta el instalador con doble clic

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

# macOS Apple Silicon (M1/M2/M3)
# Descarga FinceptTerminal-4.0.2-macOS-setup.dmg
# Abre el archivo DMG y arrastra la aplicación a la carpeta Applications

Tras la instalación, inicia desde la terminal:

# Windows
FinceptTerminal.exe

# Linux
./FinceptTerminal

# macOS
open /Applications/FinceptTerminal.app

Opción B: Despliegue con Docker (adecuado para entornos de servidor)

# Descarga la imagen oficial
docker pull ghcr.io/fincept-corporation/fincept-terminal:latest

# Ejecutar (requiere soporte de X Server para la interfaz gráfica)
docker run --rm \
    -e DISPLAY=$DISPLAY \
    -v /tmp/.X11-unix:/tmp/.X11-unix \
    ghcr.io/fincept-corporation/fincept-terminal:latest

Opción C: Clonar el código fuente y compilar en un solo paso (ideal para desarrolladores en Linux/macOS)

Después de clonar el repositorio, ejecuta directamente el script setup.sh: detectará el entorno, descargará dependencias y ejecutará la compilación:

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

El script gestiona automáticamente la instalación y configuración de CMake, Qt6 y Python. Al finalizar, Fincept Terminal se iniciará automáticamente.

Paso 2: Configura la API de LLM (para que los agentes de IA funcionen de verdad)

Después de iniciar Fincept Terminal, los agentes de IA necesitan conectarse a un modelo de lenguaje grande para poder ejecutarse. Ve a Settings → AI Providers:

1. Selecciona el AI Provider que quieres usar. El proyecto admite estas opciones:

OpenAI       → GPT-4o / o1 / GPT-4.5
Anthropic    → Claude 3.5 / 3.7
Google       → Gemini 1.5 / 2.0 / 2.5
Groq         → razonamiento de alta velocidad
DeepSeek     → excelente relación calidad-precio
MiniMax      → conveniente en China
OpenRouter   → agrega múltiples modelos
Ollama       → modelos locales (completamente offline)

1. Introduce la API Key correspondiente. Si tienes Ollama local, puedes ejecutar completamente sin conexión:

# Si eliges Ollama (modelo local, sin necesidad de API Key)
# Primero instala y levanta Ollama en local
ollama pull llama3.2
ollama serve

# Luego configura en Fincept Terminal:
# Provider: Ollama
# Base URL: http://localhost:11434
# Model: llama3.2

Paso 3: Conectar fuentes de datos

Fincept Terminal ofrece 100+ conectores de datos que cubren todo tipo de fuentes, desde macroeconomía hasta criptomonedas. En la página Data Sources, selecciona qué fuentes habilitar:

Fuentes de datos gratuitas (listas para usar):

# Macroeconomía
DBnomics          → series temporales globales de macroeconomía
FRED              → datos económicos de la Reserva Federal de EE. UU.
IMF              → datos del Fondo Monetario Internacional
World Bank       → indicadores de desarrollo del Banco Mundial

# Acciones y criptomonedas
Yahoo Finance    → datos históricos de acciones y cotizaciones en tiempo real
Kraken           → criptomonedas en tiempo real vía WebSocket
Polygon          → datos de acciones estadounidenses (capa gratuita limitada)

# Otros
AkShare          → datos de acciones/futuros A (China) (librería Python)
government APIs  → datos públicos de gobiernos de distintos países

Pasos generales para conectar fuentes de datos:

1. Entra en Data Sources → Add Connection
2. Elige el tipo de fuente de datos (p. ej., "Stock Market Data")
3. Completa la API Key (algunas fuentes la requieren) o deja el valor por defecto (datos públicos)
4. Haz clic en Test Connection para comprobar la conectividad
5. Confirma y los datos se sincronizarán automáticamente con el terminal

Paso 4: Crea agentes de IA y ejecuta tu primer encargo cuantitativo

Fincept Terminal integra 37 agentes de IA, agrupados en tres grandes categorías:

Agentes Trader / Investor (enfoque de inversión en valor):

Agentes Economic: análisis de datos macro, predicción de tipos de interés, modelado de inflación

Agentes Geopolitics: evaluación del impacto geopolítico y análisis de riesgos de cadena de suministro

Vamos a completar el primer encargo con el agente Buffett: analizar el valor de una acción:

1. En AI Agents → Create New Agent
2. Selecciona Buffett como plantilla base
3. Asigna una tarea: analizar el valor intrínseco de 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.

El agente Buffett llamará al módulo de análisis en Python para obtener datos financieros, ejecutará el modelo DCF (descuento de flujos de caja) y generará una estimación del valor intrínseco y el margen de seguridad con respecto al precio actual.

Paso 5: Usa el editor de nodos para construir un flujo cuantitativo

El editor de nodos es una de las funciones más potentes de Fincept Terminal: te permite combinar visualmente fuentes de datos, módulos de análisis y agentes de IA para crear flujos cuantitativos complejos, sin necesidad de escribir una sola línea de código.

Abre la página Node Editor y verás un flujo de trabajo similar al siguiente:

[Datos de Yahoo Finance] → [Limpieza de datos en Python] → [Decisión del AI Agent] → [Ejecución de órdenes al broker]
     ↑                                              ↓
  [Datos macro de FRED]                               [Salida al Portfolio]

Construye tu primer flujo cuantitativo:

1. Arrastra un nodo Data Source desde el panel lateral izquierdo y selecciona Yahoo Finance
2. Arrastra un nodo Filter y configura las condiciones de filtrado (p. ej., "PE < 15, Market Cap > 10B")
3. Arrastra un nodo Buffett Agent y conecta la salida del Filter
4. Arrastra un nodo Backtest para validar el rendimiento histórico de la estrategia
5. Haz clic en Run para ejecutar el flujo

Paso 6 (opcional): Compilar manualmente desde el código fuente

Si quieres una personalización profunda o no hay paquetes precompilados para la plataforma, puedes construir desde el código fuente. Esto requiere configurar con precisión las versiones de las dependencias.

Preparación del entorno (ejemplo: Windows):

# 1. Instala Visual Studio 2022 (incluye MSVC 19.38)
# 2. Instala CMake 3.27.7 y añádelo al PATH
# 3. Instala Ninja 1.11.1 y añádelo al PATH
# 4. Instala Qt 6.8.3 (en el instalador online, selecciona Qt 6.8.3 > MSVC 2022 64-bit)
#    Define la ruta de instalación como C:/Qt/6.8.3/msvc2022_64
# 5. Instala Python 3.11.9 y añádelo al PATH

Compilar (usando CMake Presets):

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

# Configuración de una sola vez (después de modificar CMakeLists.txt, hay que ejecutarlo de nuevo)
cmake --preset win-release

# Recompilar después de cada cambio de código
cmake --build --preset win-release

# Ejecutar
.\build\win-release\FinceptTerminal.exe

Si CMake no encuentra Qt, puede ser porque la ruta de instalación es diferente; cambia al modo manual:

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

---

Resolución de problemas frecuentes

P1: CMake falla con "Could not find Qt6 6.8.3"

Síntoma: cmake --preset win-release muestra Could not find Qt6 6.8.3.

Causa: la ruta donde instalaste Qt no coincide con la ruta de búsqueda predeterminada de CMake.

Solución:

1. Verifica que en la ruta de instalación de Qt exista el directorio lib/cmake/Qt6
2. Especifica la ruta manualmente:

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

1. Si estás probando con otra versión de Qt, puedes omitir la comprobación de versión usando -DFINCEPT_ALLOW_QT_DRIFT=ON (solo para pruebas locales; no lo uses en CI ni en versiones de lanzamiento)

P2: Versión de MSVC incompatible

Síntoma: C++ compiler version not supported o muchos errores de identificadores no definidos durante la compilación.

Causa: el proyecto exige MSVC 19.38+ (Visual Studio 2022 17.8+).

Solución:

# Comprobar versión de MSVC
cl /?

# Si la versión es demasiado baja, actualiza a la versión más reciente de VS 2022
# Enlace de descarga：https://visualstudio.microsoft.com/downloads/

P3: No coincide la versión de Python

Síntoma: se produce un fallo tras incrustar Python o aparece el error python3.x.x not found.

Causa: el proyecto exige estrictamente Python 3.11.9; otras versiones (incluidas 3.10 y 3.12) no se admiten.

Solución:

# Verifica tu versión actual de Python
python --version

# Si no es 3.11.9, instala la versión correcta
# Enlace de descarga：https://www.python.org/downloads/release/python-3119/

# En Windows, tras instalar, confirma en el PATH del sistema que la ruta de Python 3.11.9 esté antes
# En Linux puedes usar pyenv：
pyenv install 3.11.9
pyenv local 3.11.9

P4: No se puede mostrar la interfaz gráfica de Qt en Docker

Síntoma: error QPA platform: cannot connect to X server.

Causa: el contenedor Docker no tiene un entorno gráfico.

Solución:

# Linux: permitir que Docker acceda al X Server local
xhost +local:docker
docker run --rm \
    -e DISPLAY=unix$DISPLAY \
    -v /tmp/.X11-unix:/tmp/.X11-unix \
    ghcr.io/fincept-corporation/fincept-terminal:latest

P5: Los agentes de IA muestran "Connection Failed"

Síntoma: la llamada al LLM devuelve un error y el agente no puede ejecutar ninguna tarea.

Pasos de diagnóstico:

1. Confirma que la API Key es válida (prueba la clave en el sitio web oficial correspondiente)
2. Si usas Ollama, confirma que ollama serve está en ejecución
3. Si usas un proxy (red de empresa), configura las variables de entorno del proxy HTTP:

# 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. Revisa si la red permite acceder al endpoint de API del AI Provider:

# 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"

P6: Falla la autenticación al conectar el broker (Paper Trading / Cuenta real)

Síntoma: tras configurar la API del broker, aparece un mensaje de autenticación fallida.

Solución:

1. Asegúrate de que en Fincept Terminal has introducido una API Key y no la contraseña de la cuenta de trading
2. Algunos brokers (como IBKR) requieren habilitar el acceso a la API en Trader Workstation (TWS)
3. La configuración de API difiere entre Paper Trading y cuentas reales; confirma que has seleccionado el modo correcto

---

Lecturas adicionales / Direcciones de nivel avanzado

Implementar Adanos Market Sentiment para cuantificar el sentimiento

Adanos introduce datos de sentimiento de Reddit, X/Twitter, noticias financieras y Polymarket en Fincept Terminal. En Data Sources → Alternative Data → Adanos, después de configurar la API, el módulo de Equity Research mostrará una foto del sentimiento minorista agregando fuentes diversas. Puedes usar estos indicadores de sentimiento como factores dentro de una estrategia cuantitativa, combinándolos con datos financieros tradicionales para un análisis más completo.

Usar QuantLib Suite para la valoración de derivados

Fincept Terminal incluye 18 módulos cuantitativos de QuantLib, que cubren:

# Modelos de pricing
Black-Scholes para opciones
Binomial Tree para opciones americanas
Monte Carlo para valoración

# Gestión de riesgos
Cálculo de VaR (Value at Risk)
Análisis de sensibilidad de Greeks
Pruebas de estrés / análisis de escenarios

# Renta fija
Construcción de la Yield Curve
Análisis de Duration / Convexity
Optimización de portafolio de bonos

A través de la interfaz AI Quant Lab, puedes llamar a estos módulos para construir modelos de riesgo personalizados sin tener que escribir código Python a mano.

Configurar trading programático con múltiples brokers

Fincept Terminal admite integraciones de API de 16 brokers, cubriendo acciones, futuros y criptomonedas:

Brokers de India: Zerodha, Angel One, Upstox, Fyers, Dhan, Groww, Kotak,
         IIFL, 5paisa, AliceBlue, Shoonya, Motilal
Brokers de Estados Unidos: IBKR, Alpaca, Tradier
Brokers internacionales: Saxo
Criptomonedas: Kraken, HyperLiquid (WebSocket para cotizaciones en tiempo real)

Puedes conectar varios brokers al mismo tiempo y construir estrategias de arbitraje entre mercados en el editor de nodos.

AI Quant Lab: entrenamiento de modelos de ML y descubrimiento de factores

El módulo AI Quant Lab de Fincept Terminal ofrece un flujo completo de cuantificación con aprendizaje automático:

# Usar los módulos de Python
from fincept_ml import FactorDiscovery, ModelTrainer

# Descubrir automáticamente factores efectivos a partir de datos de mercado
factors = FactorDiscovery.run(data_source="yahoo_finance",
                              target="AAPL_returns",
                              n_factors=20)

# Entrenar una estrategia de trading con aprendizaje por refuerzo
strategy = ModelTrainer.train_rl(
    agent="PPO",
    environment="crypto_portfolio",
    episodes=1000
)

También admite aprendizaje supervisado (estrategias HFT), predicción de series temporales y marcos de backtesting.

Participar en el desarrollo de código abierto

Fincept Terminal es un proyecto de código abierto; ¡se agradecen contribuciones de código!

• Módulos en C++: componentes de la interfaz en Qt, conectores de datos, envoltorios de QuantLib
• Módulos en Python: nuevos modelos de análisis y estrategias de machine learning
• Agentes de IA: nuevos agentes de marcos de inversión y módulo de análisis geopolítico
• Documentación: mejorar los tutoriales de integración de cada función

Guía de contribución: docs/CONTRIBUTING.md Normas de desarrollo en C++: fincept-qt/CONTRIBUTING.md