Measure what matters.

An open-source investment dashboard for Indian investors.
Track stocks, mutual funds, SIPs, physical gold, and fixed deposits — all in one place.

Metron syncs your holdings, mutual funds, and SIPs directly from your broker. Currently Zerodha (via Kite Connect) is supported — more brokers may be added in the future.

1. Go to Kite Connect Developer Portal and sign in with your Zerodha credentials.
2. Click Create new app on the developer dashboard.
3. Fill in the app details:
   • App name: any name (e.g. "Metron")
   • Redirect URL: set based on how you'll use the app:
     • Local: http://127.0.0.1:8000/api/callback
     • Web app: https://metron.thecoducer.com/api/callback
   • Postback URL: Leave it as blank.
4. After creation, note your API Key and API Secret from the app details page.

1. Sign in to Metron with your Google account.
2. Go to Settings → Add Zerodha Account.
3. Enter a label (e.g. "Personal"), your API Key, and API Secret.
4. Click Save — credentials are stored securely in Firebase.
5. Click Login next to the account — this opens Zerodha's OAuth page where you authorize access.
6. After authorization, you're redirected back and your portfolio data loads automatically.

Multiple accounts: Repeat steps 2–5 for each Zerodha account. Each needs its own Kite Connect app with a separate API key and secret.

Follow these steps carefully to get Metron running on your local machine.

• Python 3.9+ (3.12 recommended)
• pip and venv (usually bundled with Python)
• A Firebase project with Firestore enabled
• A Google Cloud project with OAuth 2.0 configured
• A Zerodha developer account with a Kite Connect app (setup instructions above)

git clone https://github.com/thecoducer/metron.git
cd metron

Firebase Firestore stores user profiles, connected broker accounts, encrypted OAuth tokens, and spreadsheet references.

1. Go to the Firebase Console and create a new project (or select an existing one).
2. Enable Cloud Firestore:
   • Navigate to Build → Firestore Database → Create database.
   • Choose your preferred region and start in production mode.
3. Generate a service account key:
   • Go to Project Settings (gear icon) → Service Accounts.
   • Click Generate new private key — this downloads a JSON file.
4. Save the downloaded file as:

   config/firebase-credentials.json
   

Google OAuth handles user sign-in and grants the app permission to create/read Google Sheets for your financial data.

1. Go to the Google Cloud Console — use the same project linked to your Firebase project.
2. Enable required APIs:
   • Go to APIs & Services → Library.
   • Search for and enable:
     • Google Sheets API
     • Google Drive API
3. Configure the OAuth consent screen:
   • Go to APIs & Services → OAuth consent screen.
   • Choose External user type.
   • Add scopes: openid, userinfo.email, userinfo.profile, drive.file.
   • Add your Google account email as a test user (required while the app is in "Testing" mode).
4. Create OAuth client credentials:
   • Go to APIs & Services → Credentials.
   • Click Create Credentials → OAuth client ID → Web application.
   • Under Authorized redirect URIs, add:

     http://127.0.0.1:8000/api/auth/google/callback
     

   • Download the JSON file and save it as:

     config/google-oauth-credentials.json
     

These secrets are used for session signing and encrypting broker tokens. All secret files go in the config/ directory.

Flask Secret Key — signs session cookies:

python3 -c "import secrets; print(secrets.token_hex(32))" > config/flask-secret-key.txt

Broker Token Secret — encrypts cached broker access tokens at rest:

python3 -c "import secrets; print(secrets.token_hex(32))" > config/zerodha-token-secret.txt

Alternatively, set FLASK_SECRET_KEY and ZERODHA_TOKEN_SECRET as environment variables instead of files.

All settings have sensible defaults. Create a .env file in the project root only if you need to override them:

# Server
METRON_UI_HOST=127.0.0.1
METRON_UI_PORT=8000

# Timeouts (seconds)
METRON_REQUEST_TOKEN_TIMEOUT=180

# Features
METRON_ALLOW_BROWSER_API_ACCESS=false

Redirect URLs must match your config. Ensure the host and port in your broker app's redirect URL and Google OAuth redirect URI match METRON_UI_HOST and METRON_UI_PORT.

• Broker callback: http://<host>:<port>/api/callback
• Google OAuth: http://<host>:<port>/api/auth/google/callback

./start.sh

This script automatically:

1. Creates a Python virtual environment (run_server/)
2. Installs all dependencies from requirements.txt
3. Loads .env (if present)
4. Starts the development server

Open http://127.0.0.1:8000/ in your browser.

If you want to run the same WSGI entrypoint used in production, start Gunicorn from the project root:

python3 -m venv run_server
source run_server/bin/activate
pip install -r requirements.txt
PORT=8000 gunicorn -c gunicorn.conf.py wsgi:app

This uses wsgi.py and gunicorn.conf.py. When FLASK_SECRET_KEY or ZERODHA_TOKEN_SECRET are not already set in the environment, startup will now automatically load them from:

• config/flask-secret-key.txt
• config/zerodha-token-secret.txt

Firebase and Google OAuth credentials are already resolved from their local files by the application code:

• config/firebase-credentials.json
• config/google-oauth-credentials.json

If you want local URLs to match OAuth callbacks exactly, set the local port before starting Gunicorn:

export METRON_UI_HOST=127.0.0.1
export METRON_UI_PORT=8000
export PORT=8000
gunicorn -c gunicorn.conf.py wsgi:app

All files in config/ are git-ignored — never commit them.

./run_tests.sh

metron/
├── main.py                          # Entry point (development server)
├── wsgi.py                          # WSGI entry point (production)
├── gunicorn.conf.py                 # Gunicorn config (production)
├── Dockerfile                       # Container build
├── render.yaml                      # Render.com deployment blueprint
├── requirements.txt                 # Runtime dependencies
├── requirements-prod.txt            # Production-only dependencies
├── requirements-dev.txt             # Dev/test dependencies
├── pyproject.toml                   # Ruff linter & formatter config
├── start.sh                         # Local startup script
├── run_tests.sh                     # Test runner
│
├── config/                          # Secrets & credentials (git-ignored)
│   ├── firebase-credentials.json
│   ├── google-oauth-credentials.json
│   ├── flask-secret-key.txt
│   └── zerodha-token-secret.txt
│
├── app/
│   ├── server.py                    # Flask app factory
│   ├── routes.py                    # Route definitions & API endpoints
│   ├── services.py                  # Portfolio data aggregation
│   ├── fetchers.py                  # Data fetching orchestration
│   ├── config.py                    # Config loading from env vars
│   ├── constants.py                 # App-wide constants & defaults
│   ├── cache.py                     # In-memory cache with TTL
│   ├── utils.py                     # SessionManager, StateManager, helpers
│   ├── firebase_store.py            # Firestore persistence layer
│   ├── error_handler.py             # Exceptions & retry decorators
│   ├── logging_config.py            # Logger setup
│   ├── middleware.py                # Request middleware
│   │
│   ├── api/
│   │   ├── auth.py                  # Zerodha OAuth authentication
│   │   ├── google_auth.py           # Google OAuth 2.0 flow
│   │   ├── zerodha_client.py        # Multi-account Zerodha fetcher
│   │   ├── holdings.py              # Stock & MF holdings service
│   │   ├── sips.py                  # SIP data service
│   │   ├── market_data.py           # Market data (NSE, Yahoo Finance)
│   │   ├── google_sheets_client.py  # Google Sheets integration
│   │   ├── ibja_gold_price.py       # IBJA gold price scraper
│   │   ├── physical_gold.py         # Physical gold P/L calculations
│   │   ├── fixed_deposits.py        # FD compound interest calculations
│   │   ├── user_sheets.py           # Sheet tab configs (headers, fields)
│   │   └── base_service.py          # Base class for data services
│   │
│   ├── static/                      # CSS, JavaScript, images
│   └── templates/                   # Jinja2 HTML templates
│
└── tests/                           # Test suite

MIT — For personal use.