Fincept Terminal Getting Started: An All-in-One Open-Source Quant Trading Platform

Fincept Terminal is an open-source quantitative finance terminal developed by Fincept Corporation. Its core positioning is clear: replace the Bloomberg terminal—often costing tens of thousands per year—with a free open-source tool, while enabling ordinary developers to build their own quantitative trading systems.

Built natively with C++20 + Qt6, it delivers performance several orders of magnitude higher than Electron/Web applications. Embedded Python modules provide full CFA-level analytical capabilities. Thirty-seven AI agents cover a wide range of frameworks—from value investing to geopolitics. Over 100 data connectors span every source type, from government macroeconomic data to cryptocurrencies. The repository is hosted on GitHub at Fincept-Corporation/FinceptTerminal and uses the AGPL-3.0 open-source license.

---

Difficulty / Time / What You’ll Gain

Beginner | About 30 minutes | You’ll learn the end-to-end process to install and run your first AI quant strategy on Windows / macOS / Linux.

---

Target Audience

• Developers with 1–4 years of experience who want to build their own quantitative trading systems
• People interested in financial data analysis and AI-assisted investing, but who don’t have a formal finance background
• Anyone who wants a free open-source tool to replace expensive Bloomberg terminal features (annual fees typically range from thousands to tens of thousands of dollars)

---

Core Dependencies & Environment

System Requirements

---

Full Project Directory Structure

FinceptTerminal/
├── fincept-qt/                 # C++ main application
│   ├── src/                   # Core C++ source code
│   │   ├── core/             # Core modules
│   │   ├── ui/               # Qt UI components
│   │   └── python/           # Python binding layer
│   ├── scripts/              # Build scripts
│   ├── CMakeLists.txt        # C++ build configuration
│   └── CMakePresets.json     # Cross-platform build presets (important)
├── docs/                      # Developer documentation
├── Dockerfile                 # Docker image configuration
├── setup.sh                  # One-click build script for Linux/macOS
└── funding.json              # Community sponsorship configuration

---

Step-by-Step Setup

Step 1: Download and Install Fincept Terminal

The project provides three installation options—choose the one that fits you best.

Option A: Download precompiled installers (recommended; best for beginners)

The latest release is v4.0.2. Visit the Releases page to download the installer for your platform:

# Windows x64
# Download FinceptTerminal-4.0.2-win64-setup.exe and double-click to run the installer

# Linux x64
# Download 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)
# Download FinceptTerminal-4.0.2-macOS-setup.dmg
# Open the DMG and drag the app into the Applications folder

After installation, launch from the terminal:

# Windows
FinceptTerminal.exe

# Linux
./FinceptTerminal

# macOS
open /Applications/FinceptTerminal.app

Option B: Docker deployment (for server environments)

# Pull the official image
docker pull ghcr.io/fincept-corporation/fincept-terminal:latest

# Run (requires X Server support for GUI)
docker run --rm \
    -e DISPLAY=$DISPLAY \
    -v /tmp/.X11-unix:/tmp/.X11-unix \
    ghcr.io/fincept-corporation/fincept-terminal:latest

Option C: Clone the source and build in one step (for Linux/macOS developers)

After cloning the repository, run the setup.sh script directly. It will automatically detect your environment, download dependencies, and execute the build:

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

The script automatically handles installation and configuration for CMake, Qt6, and Python. When the run finishes, Fincept Terminal will start automatically.

Step 2: Configure the LLM API (so AI agents can truly work)

Once Fincept Terminal is running, AI agents need to connect to a large language model to operate. Go to Settings → AI Providers:

1. Choose the AI Provider you want to use. The project supports the following options:

OpenAI       → GPT-4o / o1 / GPT-4.5
Anthropic    → Claude 3.5 / 3.7
Google       → Gemini 1.5 / 2.0 / 2.5
Groq         → Fast reasoning
DeepSeek     → Great value for money
MiniMax      → Convenient in China
OpenRouter   → Aggregates multiple models
Ollama       → Local models (fully offline)

1. Enter the corresponding API Key. If you have local Ollama, you can run fully offline:

# If you choose Ollama (local model; no API Key needed)
# First install and start Ollama locally
ollama pull llama3.2
ollama serve

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

Step 3: Connect Data Sources

Fincept Terminal provides 100+ data connectors covering all kinds of sources—from macroeconomics to cryptocurrencies. Open the Data Sources page and select which data sources you want to enable:

Free data sources (ready to use out of the box):

# Macroeconomics
DBnomics          → Global macroeconomic time-series data
FRED              → Federal Reserve economic data
IMF              → International Monetary Fund data
World Bank       → World Bank development indicators

# Stocks & Cryptocurrencies
Yahoo Finance    → Historical stock data, live quotes
Kraken           → Real-time cryptocurrency WebSocket
Polygon          → US stock data (free tier is limited)

# Others
AkShare          → Domestic A-share/futures data (Python library)
government APIs  → Public government data from different countries

General steps to connect a data source:

1. Go to Data Sources → Add Connection
2. Choose the data source type (e.g., "Stock Market Data")
3. Enter an API Key (some sources require it) or keep the default (public data)
4. Click Test Connection to verify connectivity
5. After confirmation, the data will automatically sync to the terminal

Step 4: Create AI Agents and Run Your First Quant Task

Fincept Terminal includes 37 AI agents, grouped into three major categories:

Trader / Investor agents (value investing faction):

Economic agents: macro data analysis, interest rate forecasting, inflation modeling

Geopolitics agents: assessing geopolitical impacts, supply-chain risk analysis

Let’s use the Buffett agent to complete your first task—analyzing a stock’s value:

1. Go to AI Agents → Create New Agent
2. Choose Buffett as the base template
3. Give him a task: analyze the intrinsic value of 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.

The Buffett agent will call the Python analysis modules to fetch financial data, run a DCF (discounted cash flow) model, and output the intrinsic value estimate along with the margin of safety relative to the current price.

Step 5: Use the Node Editor to Build a Quant Workflow

The node editor is one of the strongest features in Fincept Terminal—it lets you visually combine data sources, analysis modules, and AI agents to build complex quant workflows without writing a single line of code.

Open the Node Editor page and you’ll see a workflow like the following:

[Yahoo Finance Data] → [Python Data Cleaning] → [AI Agent Decision] → [Broker Order Execution]
     ↑                                              ↓
  [FRED Macro Data]                               [Results Output to Portfolio]

Build your first quant workflow:

1. Drag a Data Source node from the left panel and select Yahoo Finance
2. Drag in a Filter node and configure the filtering conditions (e.g., "PE < 15, Market Cap > 10B")
3. Drag in a Buffett Agent node and connect it to the Filter output
4. Drag in a Backtest node to validate the strategy’s historical performance
5. Click Run to execute the workflow

Step 6 (Optional): Manually Build from Source

If you want deeper customization, or if you don’t have a precompiled package available for your platform, you can build from source. This requires exact dependency version configuration.

Environment Preparation (Windows as an example):

# 1. Install Visual Studio 2022 (includes MSVC 19.38)
# 2. Install CMake 3.27.7 and add it to PATH
# 3. Install Ninja 1.11.1 and add it to PATH
# 4. Install Qt 6.8.3 (use the online installer; select Qt 6.8.3 > MSVC 2022 64-bit)
#    Set install path to C:/Qt/6.8.3/msvc2022_64
# 5. Install Python 3.11.9 and add it to PATH

Build (using CMake Presets):

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

# One-time configuration (re-run before modifying CMakeLists.txt)
cmake --preset win-release

# Rebuild after each code change
cmake --build --preset win-release

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

If CMake can’t find Qt (often due to a different install path), switch to manual mode:

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

---

Common Troubleshooting

Q1: CMake error "Could not find Qt6 6.8.3"

Symptoms: cmake --preset win-release outputs Could not find Qt6 6.8.3.

Cause: Your Qt install path doesn’t match CMake’s default search paths.

Solution:

1. Confirm there is a lib/cmake/Qt6 directory inside your Qt install path
2. Manually specify the path:

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

1. If you’re testing with a different Qt version, you can pass -DFINCEPT_ALLOW_QT_DRIFT=ON to bypass the version check (for local testing only—do not use it in CI or release builds)

Q2: MSVC version incompatibility

Symptoms: C++ compiler version not supported or many “undefined identifier” errors mid-build.

Cause: The project requires MSVC 19.38+ (Visual Studio 2022 17.8+).

Solution:

# Check MSVC version
cl /?

# If it’s too low, upgrade to the latest VS 2022
# Download: https://visualstudio.microsoft.com/downloads/

Q3: Python version mismatch

Symptoms: The embedded Python crashes, or you see python3.x.x not found.

Cause: The project strictly requires Python 3.11.9. Other versions (including 3.10 and 3.12) are not supported.

Solution:

# Check your current Python version
python --version

# If it’s not 3.11.9, install the correct version
# Download: https://www.python.org/downloads/release/python-3119/

# On Windows, after installation, ensure the Python 3.11.9 path is earlier in the system PATH
# On Linux you can use pyenv:
pyenv install 3.11.9
pyenv local 3.11.9

Q4: Qt GUI can’t be displayed under Docker

Symptoms: You get the error QPA platform: cannot connect to X server.

Cause: There is no GUI environment inside the Docker container.

Solution:

# Linux: allow Docker to access your local X Server
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: AI agents show "Connection Failed"

Symptoms: The LLM call returns an error, and the agent can’t execute any tasks.

Troubleshooting steps:

1. Confirm the API Key is valid (you can test it on the corresponding official site)
2. If using Ollama, confirm ollama serve is running
3. If using a proxy (corporate network), configure the HTTP proxy environment variables:

# 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. Check whether your network can reach the AI Provider API endpoints:

# 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: Broker authentication fails (Paper Trading / Live Trading)

Symptoms: After entering the broker API configuration, authentication fails.

Solution:

1. Confirm you entered an API Key in Fincept Terminal, not the trading account password
2. Some brokers (e.g., IBKR) require enabling API access permission in Trader Workstation (TWS)
3. Paper Trading and live trading API configurations differ—make sure you selected the correct mode

---

Further Reading / Advanced Directions

Integrate Adanos Market Sentiment for Quantified News & Social Sentiment

Adanos brings sentiment data from Reddit, X/Twitter, financial news, and Polymarket into Fincept Terminal. Go to Data Sources → Alternative Data → Adanos, configure the API, and the Equity Research module will display cross-source retail sentiment snapshots. You can use sentiment indicators as factors in your quant strategies and combine them with traditional financial data for more comprehensive analysis.

Use QuantLib Suite for Derivatives Pricing

Fincept Terminal includes 18 QuantLib quant modules covering:

# Pricing models
Black-Scholes option pricing
Binomial Tree American options
Monte Carlo pricing

# Risk management
VaR (Value at Risk) calculation
 Greeks sensitivity analysis
 Stress testing / scenario analysis

# Fixed income
Yield curve construction
Duration / Convexity analysis
Bond portfolio optimization

Through the AI Quant Lab interface, you can call these modules to build custom risk models without manually writing Python code.

Configure Multi-Broker Support for Programmatic Trading

Fincept Terminal supports API integrations for 16 brokers, covering stocks, futures, and cryptocurrencies:

Indian brokers: Zerodha, Angel One, Upstox, Fyers, Dhan, Groww, Kotak,
                IIFL, 5paisa, AliceBlue, Shoonya, Motilal
US brokers: IBKR, Alpaca, Tradier
International brokers: Saxo
Cryptocurrencies: Kraken, HyperLiquid (WebSocket real-time quotes)

You can connect multiple brokers simultaneously and build cross-market arbitrage strategies in the node editor.

AI Quant Lab: ML Model Training & Factor Discovery

Fincept Terminal’s AI Quant Lab module provides a complete machine-learning quant workflow:

# Use Python modules
from fincept_ml import FactorDiscovery, ModelTrainer

# Automatically discover effective factors from market data
factors = FactorDiscovery.run(data_source="yahoo_finance",
                              target="AAPL_returns",
                              n_factors=20)

# Train reinforcement learning trading strategies
strategy = ModelTrainer.train_rl(
    agent="PPO",
    environment="crypto_portfolio",
    episodes=1000
)

It also supports supervised learning (HFT-style strategies), time-series forecasting, and backtesting frameworks.

Contribute to Open-Source Development

Fincept Terminal is an open-source project—contributions are welcome:

• C++ modules: Qt UI components, data connectors, QuantLib wrappers
• Python modules: new analysis models, machine learning strategies
• AI agents: new investment framework agents, geopolitics analysis modules
• Documentation: expand integration tutorials for each feature

Contribution guide: docs/CONTRIBUTING.md C++ development standards: fincept-qt/CONTRIBUTING.md