My father is not technical by profession. He can read a balance sheet, but the modern machinery of investing (finance portals, stock screeners, a screen full of ratios) was never his world. And yet he invests. So, again and again, he would call me with the same simple question: “Is this a good stock? Should I put money here?” Every time, I ended up doing the same thing by hand: pulling the live numbers, checking the fundamentals, and explaining them back in plain language he could act on. Kaudee (कौड़ी) is what happened when I turned that into software. It is an AI research assistant for stocks and mutual funds that does exactly what I did for him: it reads the real numbers and explains them simply, but never invents a figure. This is a case study of how it is built, and of a GenAI pattern called grounded generation that makes a language model trustworthy enough to hand to someone who takes its answer at face value.

01Kaudee in one screen

02Why you can’t just point an LLM at the market

A large language model predicts the next token; it does not look up a fact. Ask it for Reliance’s P/E and it will emit a plausible-looking number drawn from patterns in its training data: possibly months stale, possibly for the wrong listing, possibly invented outright. It will not tell you which. In casual chat that is harmless. In investing, a single confidently wrong figure can move real money, and the fluency of the answer makes the error more dangerous, not less, because it reads like authority. Someone like my father, who cannot tell a real P/E from an invented one, would simply believe it and act. That is the exact person this tool is built for, and the exact reason the numbers can never be left to the model.

So the design problem was precise: keep the language model’s fluency, remove its licence to make numbers up. The comparison below frames the two failure modes and the target.

Where Kaudee sits

Fluency on one axis, numeric trustworthiness on the other. A terminal is trustworthy but unreadable; a chatbot is readable but untrustworthy. The goal is the top-right corner.

03Core pattern: grounded generation

Kaudee is deliberately not a fine-tuned model, not a price-forecasting time-series model, and not vector-database RAG. It is grounded, context-augmented generation. The system splits every request into two zones: a deterministic zone where code fetches and computes every figure, and a generative zone where the LLM is handed those locked figures and asked only to explain them. The numbers are frozen before the model ever sees them.

04System architecture

Six layers, each replaceable. AI is only one band; the trust comes from the compute and data layers beneath it.

05How one AI analysis runs

What actually happens between a tap and a paragraph of insight. Note that the model is the last step, and it receives only finished numbers.

06Inside the AI layer

Model routing & fallback

Inference runs on Groq’s low-latency open-weight models. Rather than depend on a single model, requests route through an ordered list: the first model that responds wins, and any error, rate-limit or outage silently cascades to the next. It keeps the assistant responsive even when one backend has a bad minute.

Prompt architecture: context engineering, not a chat

The prompt is engineered, not conversational. It has three fixed parts: a role & guardrail instruction (you are a research assistant; explain, do not advise; use only the figures given), a grounded-context block (the deterministic metrics, clearly labelled), and the user’s question. Because the numbers live in the context rather than in the model’s memory, the same prompt on any model yields the same facts, and the model is swappable precisely because it is doing interpretation, not recall.

Streaming & responsiveness

Responses stream token-by-token, so a multi-paragraph analysis feels instant rather than arriving after a long pause. It is a small detail that matters a lot on a phone, which is where most pilot users open it.

07Data pipeline and verification

The AI is only as trustworthy as the numbers under it, so the data layer does the unglamorous work. Prices and fundamentals come from yfinance; fund NAV history from mfapi.in; and the fee and holdings data that matters most (expense ratio, AUM, top holdings) is read from the fund fact-sheet and cross-checked by ISIN, the fund’s unique identifier, so a “Bluechip Fund” is never confused with a differently-managed fund of a similar name. Where a provider omits a field, Kaudee reconstructs it from a financial identity rather than leaving a blank or letting the model fill it in.

08Techniques used

GenAI and engineering techniques this project exercises, read as a capability map.

09What runs where

Capability coverage across the three supported markets; feature availability follows each market’s data sources.

10Design decisions & trade-offs

11Why this pattern generalises

Strip away the finance and the shape is reusable. Anywhere an LLM has to be trustworthy with real, computable data (a pricing assistant, a clinical-metrics explainer, an ops dashboard that talks, a compliance summariser), the same split applies: compute the ground truth deterministically, hand it to the model as context, and constrain the model to interpretation. You get the fluency of GenAI without betting the outcome on the model’s memory. Kaudee is proof that the pattern works end to end, in a domain where being wrong actually costs something. And it started with the simplest test I know: could I hand it to my father, and would the answer be one he could trust?