AutoFinance: Your AI Financial Command Center, right inside the terminal!

Rahul — Mon, 16 Feb 2026 06:22:07 +0000

This is a submission for the GitHub Copilot CLI Challenge

Why Leave the Terminal?

As developers, we live in the terminal. So why do we keep switching to 20 different browser tabs just to check market volatility, technical indicators, or portfolio drift?

I wanted to see if I could build a professional-grade financial research desk that lives exactly where I do. The result is AutoFinance: a heavy-duty orchestration of 13 specialized MCP (Model Context Protocol) servers that turn your command line into a high-speed financial command center.

Demo

The 13-Server Engine Room

To power these agents, I stood up 13 microservices using the Model Context Protocol. Each server handles a specific domain:

Port	Server	Responsibility
9001	Market	Real-time data via Yahoo Finance & Binance
9002	Risk	Automated trade validation and position sizing
9005	Technical	Crunches RSI, MACD, and Bollinger Bands
9006	Fundamental	P/E ratios, ROE, and growth metrics
9008	News	Local sentiment analysis on market headlines
9012	Simulation	Monte Carlo scenarios for stress testing

Key Features

📈 Real-Time Market Data: Connects directly to Yahoo Finance and Binance (via WebSockets) to stream live prices. No staleness—just raw, real-time data.
📡 Multi-Channel Global Notifications: Never miss a beat. The system pushes critical alerts to where you actually live:
- Slack & Discord: Get trade confirmations, price spikes, and agent debates in your channels.
- SMS & WhatsApp: Urgent margin calls or crash alerts sent directly to your phone.
- Email: Daily portfolio summaries and audit reports.
🛡️ Automated Risk Guardrails: The Risk Server enforces strict position limits (max 5%) and stop-losses automatically. It rejects any trade that violates your pre-set safety policy.
💬 Natural Language Interface: Deep copilot CLI integration lets you "chat" with your portfolio. "Hey, sell half my Bitcoin if RSI > 80."
📊 Comprehensive Analysis:
- Technical: Real-time RSI, MACD, and Bollinger Bands.
- Fundamental: P/E ratios, ROE, and growth metrics.
- Sentiment: Scans news headlines to gauge the current market mood.

How GitHub Copilot CLI Saved My Sanity

It helped me build this project in less than 36 hours!!

AutoFinance/
├── .github/                       # COPILOT BRAIN 🧠
│   ├── copilot-instructions.md    # The "Bible" (Context & Rules)
│   ├── mcp-config.json            # Local MCP Server Config
│   ├── agents/                    # Specialized Personas
│   │   ├── mcp-server-developer.md
│   │   ├── financial-analyst.md
│   │   ├── cli-dashboard-dev.md
│   │   └── test-engineer.md
│   ├── skills/                    # Reusable Knowledge
│   │   ├── financial-data-validation/
│   │   ├── mcp-server-debugging/
│   │   └── technical-analysis-impl/
│   ├── instructions/              # Path-Specific Context
│   │   ├── mcp-servers.md
│   │   └── tests.md
│   └── hooks/                     # Automation Scripts
│       └── hooks.json             # Pre/Post-execution logic
├── mcp-servers/                   # THE 13 MICROSERVICES
│   ├── market/                    # Yahoo Finance Integration
│   ├── technical/                 # RSI/MACD/Bollinger Logic
│   ├── sentiment/                 # NewsAPI + LLM Analyzer
│   ├── risk/                      # Compliance & Limits Engine
│   └── ... (10 others)
└── cli/                           # The Textual Dashboard UI

(I specifically organized .github/ to leverage Copilot's ability to read configuration files. This ensures every suggestion respects the project's architecture.)

Building a system with 13 microservices is not easy. Honestly, if I had to manually manage the boilerplate for every server, I’d still be writing imports.

Here is how Copilot CLI helped me:

1. The @mcp-server-developer Persona

I defined custom instructions so Copilot knew exactly how I wanted my MCP servers structured. When I needed the Volatility Server, I didn't write code; I just talked to my terminal:

copilot --agent=mcp-server-developer "Create a volatility server on port 9010 using our standard SSE transport."
It generated the Pydantic models and error handling that matched the rest of my stack perfectly.

2. Local MCP Integration

I configured Copilot CLI to actually talk to my running AutoFinance servers. By mapping my local tools in ~/.copilot/mcp-config.json, I could ask the CLI real-time questions:

Me: "What's the current RSI for NVDA?"
Copilot: "The current RSI for NVDA is 72.4 (Overbought). Recommendation: Wait for a pullback."
It bridged the gap between a coding assistant and a production console.

3. Living Documentation

Using .github/copilot-instructions.md, I gave Copilot the knowledge of the project—things like port ranges and "no hardcoded API keys" policy. This meant I never had to correct it on the small stuff. It just knew the architecture.

Screenshots

Landing UI

Dashboard

Setup in 30 Seconds

git clone https://github.com/crypticsaiyan/AutoFinance.git
pip install -r mcp-servers/requirements.txt
pip install -r cli/requirements.txt
./start_sse_servers.sh  # Fire up the 13-server swarm
python cli/main.py      # Launch the Command Center
# see the repo for more advanced setup

I really enjoyed and learnt a lot making this project (plus burnt a lot of credits too :P)

made by: crypticsaiyan
GitHub Repository: crypticsaiyan/AutoFinance

A practical walkthrough of building a real-time multilingual experience in a Next.js app

Rahul — Sun, 08 Feb 2026 06:58:23 +0000

TL;DR: I built PolyDub, a real‑time multilingual video dubbing app. This post shows the practical pieces that make it work: UX, WebSockets, streaming STT → translate → TTS, and automated UI i18n. You can reuse the same approach for any React app.

The use case (why this matters)

Ever tried hosting a live webinar for a global audience? You’re speaking English, half your audience prefers Spanish, and everyone else is quietly struggling.

PolyDub turns that into: speak once, listeners hear you in their language. It works for:

Live broadcasts (one‑to‑many)
Multilingual meetings (many‑to‑many)
Demos, classes, and community events

The core idea:

At a high level, PolyDub is just a fast loop:

Audio In → Speech‑to‑Text → Translate → Text‑to‑Speech → Audio Out

Step 1: Build a UI that’s ready for multiple languages

I started with a Next.js app and a UI built from small components (buttons, selects, transcript panels). The key is keeping copy centralized so it can be extracted and translated.

Tip: Avoid hard‑coding strings deep in components. Make them easy to collect.

Step 2: Automate UI translation

Manually translating UI strings is a time sink. I used Lingo.dev to automate extraction and generation of locale files.

What that gets you:

Automatic string extraction from React components
Versionable JSON locale files
One build step to update all languages

Example flow

Write UI in English
Run build
Locale files are generated
UI is instantly multilingual

Step 3: Stream audio and translate in real time

For live audio, I used WebSockets and a Node server to keep latency low. The server:

Receives audio chunks from the speaker
Runs speech‑to‑text (Deepgram STT)
Translates text (Lingo.dev SDK)
Generates speech (Deepgram TTS)
Streams the audio to listeners

Diagram (simple + memorable)

Browser → WS Server → STT → Translate → TTS → WS → Browser

Step 4: Keep it human‑sounding

Synthetic voices can feel robotic, so I used Deepgram Aura voices for more natural delivery. This makes a huge difference for engagement.

Tip: Let users pick voices per language. It adds personality and makes the app feel premium.

Step 5: Add transcripts for trust

People trust systems more when they can see what they’re hearing. I show:

Source transcript (what was said)
Target transcript (what was translated)

This doubles as accessibility and debugging during live sessions.

The architecture

Next.js frontend for the UI
WebSocket server for streaming audio
Deepgram for STT + TTS
Lingo.dev for translations + UI i18n

What you can copy into your own app

You don’t need to build a full dubbing platform. You can still:

Add multilingual UI in one build step
Show real‑time translated captions
Offer a translated audio track for live events

Wrap‑up

The goal isn’t to impress with AI — it’s to remove friction. When people can understand you instantly, you unlock a much bigger audience.

Github: https://github.com/crypticsaiyan/Polydub

Forem: Rahul