DEV Community: swapnil shingare

Building a Smart AI Health Assessment Chatbot with Streamlit and Generative AI

swapnil shingare — Wed, 18 Jun 2025 11:07:51 +0000

In the world of preventive healthcare, data-driven insights can empower people to make better lifestyle decisions. That's why I built an AI-powered Health Assessment Chatbot that not only asks meaningful health-related questions but also generates detailed, personalized health analysis reports — all through a friendly and interactive web interface.

🚀 What I Built
The Health Assessment Chatbot is a smart application that:

Interactively asks health and lifestyle questions.

Performs real-time calculations and health evaluations.

Uses Generative AI to provide tailored recommendations.

Generates a comprehensive health report based on your responses.

Here’s a snapshot from a sample report it produces:

📊 Sample Health Summary
Overall Health Score: 76 / 100
Moderate risk: Good health with room for improvement.

Key Metrics:

BMI: 24.9 (Normal)

Waist-to-Height Ratio (WHTR): 0.471 (Good)

Resting Metabolic Rate: 1926 kcal/day

Daily Calorie Goal: 2312 kcal

Category Breakdown:

✅ Body Profile: 95/100

⚠ Lifestyle: 79/100

⚠ Stress Management: 63.3/100

❌ Exercise: 20/100

✅ Hydration: 90/100

Hydration Reminder: Drink ~12 glasses/day (current: 2750ml)

Personalized Tips: AI-generated suggestions for diet, exercise, and stress.

🧰 Tech Stack
This project combines the power of data science and modern web tools:

Python 🐍 – Core logic, health metric calculations.

Streamlit 🌐 – Quick and beautiful UI for interaction.

Generative AI 🧠 – Provides intelligent analysis and custom recommendations.

Pandas – For data wrangling.

NumPy – For numerical operations.

💡 Key Features
🤖 Conversational UI: Feels like talking to a health assistant.

📈 Real-time Health Metrics: BMI, WHTR, BMR, hydration, calorie needs, and more.

📋 AI Recommendations: Diet, exercise, sleep, and stress management tips.

📤 Exportable Report: Users can save or share their health reports.

🔁 Assessment Retake: Restart the chat anytime to update data.

🔍 How It Works
User answers health questions → Age, weight, diet, activity, hydration, sleep, etc.

AI and Python backend calculates:

BMI, WHTR, Metabolic Rate

Daily calorie needs

Hydration percentage

LLM generates recommendations for improvement.

Streamlit renders a beautiful report with charts and metrics.

🎯 Future Plans
📱 Mobile responsiveness and deployment to the cloud.

🩺 Doctor-mode integration for medical professionals.

🧬 Adding more complex indicators like blood sugar, lipid profile, etc.

📚 Long-term trend analysis with user accounts.

🙌 Final Thoughts
Healthcare shouldn't be reactive. With AI and data, we can make it proactive. This project is just a small step in that direction — helping people understand and improve their health through meaningful interaction and actionable insights.

Let me know your thoughts, suggestions, or ideas to improve this further! 💬

Building an AI Stock Forecasting API

swapnil shingare — Mon, 09 Jun 2025 09:18:13 +0000

🧠 Build an AI Stock Forecasting API with LangGraph, OpenAI, and FastAPI
Want to predict stock prices using modern AI tools? In this guide, we’ll build a production-grade API using LangGraph, OpenAI, and FastAPI — powered by AI agents that:

✅ Analyze financial news
✅ Analyze stock charts & trends
✅ Predict price forecasts with confidence levels & sentiment
✅ Suggest short- and long-term selling targets
✅ Return elegant HTML for direct frontend display

🧱 Project Architecture
Layer Tech Stack
🧠 AI Reasoning LangGraph + OpenAI GPT-4
📉 Stock Data Yahoo Finance via yfinance
📰 News Custom scraper or NewsAPI
🔁 Backend FastAPI
⚡ Caching Redis / FAISS
🧩 Agents Modular, parallel AI agents

🧠 AI Agent Design
We created three modular AI agents:

NewsAgent: Fetches and summarizes the latest news for a stock.

TrendAgent: Analyzes historical prices and technical patterns.

PredictionAgent: Uses output from News & Trend agents + stock history to predict:

Stock prices for 7d, 15d, 1mo, and 3mo

Short- and long-term sell targets

📈 Bullish, 📉 Bearish, 🤝 Neutral sentiment

🔍 Confidence level: High / Medium / Low

🧭 Process Flow Diagram

Here's how the LangGraph flow looks:

Start([🔄 Start API Call]) --> NewsAgent[🗞️ News Agent]
Start --> TrendAgent[📊 Trend Agent]
NewsAgent --> Combine[🔗 Merge Outputs]
TrendAgent --> Combine
Combine --> PredictionAgent[🔮 Prediction Agent]
PredictionAgent --> Return([📤 Return HTML Result])

NewsAgent and TrendAgent run in parallel

PredictionAgent uses their output to forecast intelligently

🔮 Prediction Agent Sample Logic

def predict_future(stock, news, trend):
history_summary = get_history_summary(stock)

prompt = (
    f"Stock: {stock}\n\n"
    f"News: {news['summary']}\n"
    f"Trend: {trend['analysis']}\n"
    f"History: {history_summary}\n\n"
    f"Predict future stock price ranges:\n"
    f"  - 7d, 15d, 1mo, 3mo\n"
    f"Suggest:\n"
    f"  - Short-term and long-term sell targets\n"
    f"Provide sentiment (Bullish/Neutral/Bearish) and confidence level\n\n"
    f"Output as styled HTML with headers and bullet points."
)

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}],
    max_tokens=800
)
return {"html_prediction": response.choices[0].message.content}

🧪 Example HTML Output

📈 15-Day Price Forecast

7 Days: ₹3,420 – ₹3,480
15 Days: ₹3,500 – ₹3,570

🎯 Sell Targets

Short-term: ₹3,550
Long-term: ₹3,700+

📊 Sentiment

🚀 Bullish – Positive momentum and rising volumes.

🔍 Confidence

High – Aligned news and technical signals, with historical support.

⚡ Frontend Integration
Return the prediction as HTMLResponse from your FastAPI backend:

from fastapi.responses import HTMLResponse
@app.post("/predict", response_class=HTMLResponse)
async def predict_stock(...):
result = await flow.invoke(input)
return result["html_prediction"]

Inject in React or Vue:

💾 Caching for Performance
Use Redis or FAISS to cache:

Past news summaries

Processed trend data

Full prediction HTML for frequently requested stocks

import redis

redis_client = redis.Redis(host="localhost", port=6379)
redis_client.set(stock_symbol, prediction_html, ex=3600)
🚀 Deployment Tips
Use uvicorn or gunicorn to serve FastAPI

Host on Render, Fly.io, or your own VPS

Secure .env for API keys

Use openai>=1.0.0 (new SDK format)

🎯 Final Thoughts
With LangGraph + FastAPI + OpenAI, you've created a fully modular, explainable stock forecasting API that:

Thinks like an AI co-analyst 🧠

Responds in seconds 🔁

Presents beautiful HTML results 🌐

Gives confidence-driven decisions for buyers & investors

For collab DM me on LinkedIn

Let me know your thoughts or suggestions on this idea in the comments below! 👇

🧠 Building a Smart Regulatory Chatbot for IRDAI Using LangChain, Angular, FastAPI & OpenAI

swapnil shingare — Thu, 29 May 2025 07:14:56 +0000

Have you ever struggled to find the latest circular or regulation from the IRDAI (Insurance Regulatory and Development Authority of India) website?

So did I — and that’s why I decided to build a full-stack AI-powered chatbot that can:

Scrape circulars and press notes from the IRDAI website
Extract and embed content from PDFs/HTML
Answer user questions with accurate regulatory information
Suggest follow-up questions like a real assistant
Provide a beautiful and modern UI using Angular + Bootstrap

In this blog, I’ll walk through the architecture, tech stack, and some cool agentic automation behind the scenes.

🚀 Overview: What I Built

The IRDAI Chatbot is a fully automated system that:

Scrapes and downloads IRDAI circulars across all paginated pages
Parses and embeds PDFs using LangChain + OpenAI embeddings
Stores the embeddings in a local Chroma vectorstore
Uses a smart LangChain QA Agent to answer questions using RAG (retrieval-augmented generation)
Offers an interactive, smooth Angular frontend with live chat, typing effects, suggestion bubbles, and animated scroll
Suggests relevant follow-up questions based on each answer!

🧰 Tech Stack

Layer	Tech
🧠 LLM	OpenAI GPT-4 via LangChain
🧱 Vectorstore	ChromaDB
📚 Embedding	`OpenAIEmbeddings`
🔍 RAG	LangChain QA chains
🧩 Agent Framework	LangGraph
🔧 Backend	FastAPI
🧼 PDF Parsing	PyMuPDF
🌐 Frontend	Angular 17 + Bootstrap 5
🤖 Scraping	Selenium + BeautifulSoup
🔁 Async	Python `asyncio` + batching

🧠 Backend: AI Agent Architecture

I built a smart multi-step LangGraph agent with these nodes:

Scrape Node — uses Selenium to crawl all IRDAI circular pages, follows paginated "Next" links, and downloads PDFs
Parse Node — uses PyMuPDF to read PDF content
Embed Node — splits content into chunks and stores embeddings in Chroma
QA Node — answers questions by retrieving relevant docs using vector similarity
Suggestion Node — uses another agent to suggest follow-up questions based on the bot's answer

All nodes are reusable and callable as standalone FastAPI routes too.

🧠 Chatbot Flow: How Everything Connects

Here’s a visual flow of how the chatbot works — from user input to AI agents performing RAG-based document search and response formatting:

Text Input: User submits a question.
ChatGPT Core: Formats the query, routes it to agents.
AI Agents:
- Scraper: Collects PDFs & press notes
- ETL: Parses and embeds documents
- QA: Handles similarity search + answer generation
Database: Stores and retrieves document embeddings
Chat Interface: Formats HTML responses and suggestions

This modular design ensures scalability and clarity.

⚙️ Smart Features

✅ Async batching for large document QA (splits input across token-safe chunks)
✅ Automatic spell correction + similar question detection
✅ Answer caching to improve performance with a time-aware LRU-like strategy
✅ Suggestions engine that generates related follow-up questions using a second LLM chain
✅ Common llm_provider.py to centralize LLM configuration across the app

💬 Frontend: Angular Chat UI

The frontend is built with Angular 17 standalone components, styled with Bootstrap 5, and includes:

💡 Suggested questions before and after answers
🤖 Typing animation (blinking dots)
🎯 Smart session tracking using UUIDs
🔄 Smooth scroll-to-bottom on every update
❌ Graceful error handling
🔥 Responsive, mobile-friendly layout

🌐 FastAPI Backend

The backend exposes:

/ask — main QA endpoint
/suggest — generate follow-up questions
/scrape — run scraper
/embed — re-embed new content

You can trigger scraping + embedding via the LangGraph agent, CLI, or API — fully flexible.

🧠 Example Q&A

Q: What is Saral Jeevan Bima?

A: Saral Jeevan Bima is a standard term life insurance policy mandated by IRDAI...

Suggested follow-ups:

"Who is eligible for Saral Jeevan?"
"Is it mandatory for insurers?"
"What are the premium limits?"

💡 Lessons Learned

🔍 LangGraph is amazing for building modular multi-step agent flows.
⚠️ Be cautious of OpenAI token limits — I had to chunk documents smartly.
🔄 Building a good frontend experience is just as important as the backend logic.
⚡ Don’t forget caching when dealing with repeated queries or expensive operations.

🎁 What's Next

Add user authentication for session history
Push updates to a Firebase or Netlify-hosted frontend
Enable upload of user PDFs for comparison
Train a custom model on domain-specific terms

📦 Repo Coming Soon

Planning to open-source this soon. Let me know if you’d like early access!

🙌 Let’s Connect!

If you found this useful or have feedback:

💬 Comment below

🧠 Follow me on LinkedIn

💡 Have a chatbot idea? Let’s collaborate!