A deployed Python application that turns selectable PDF text into source-grounded answers. OpenAI embeddings and diversity-aware retrieval find relevant passages, GPT-4o-mini answers from that context, and expandable page excerpts let visitors inspect the evidence.
Engineering focus
- Source-grounded retrieval: Embed overlapping PDF passages, select up to four results with cosine similarity and maximal marginal relevance, and validate the source IDs returned with GPT-4o-mini answers.
Features, my contribution & outcome
My contribution
Built PDF extraction, overlapping chunking, OpenAI embeddings, MMR retrieval, and structured answer validation; connected them to a session-isolated Streamlit interface and deployed the app with server-side secrets.
Features implemented
- PDF upload with selectable-text extraction and page references
- Overlapping document chunks with preserved page numbers
- OpenAI embeddings with cosine similarity and maximal marginal relevance retrieval
- GPT-4o-mini answers with validated source IDs and expandable page excerpts
- Context-aware responses when the document does not contain an answer
- Session-isolated document indexes, clear-document controls, and request admission limits
Engineering challenge
Retrieve useful passages without repeating near-duplicates, preserve page references through generation, and keep each visitor's document separate while bounding public API usage.
Outcome
Turns PDF content into a searchable conversation with supporting page excerpts, helping readers locate answers and inspect the original source without scanning the full document.
Project details ↗A next-word prediction application powered by a trained TensorFlow/Keras LSTM. The Streamlit interface tokenizes partial sentences, prepares the saved model's input sequence, and displays three ranked next-word suggestions with their model probabilities.
Engineering focus
- End-to-end model inference: Tokenize a partial sentence, pad or truncate to the saved model's input shape, execute the LSTM on CPU, and decode three ranked predictions back to vocabulary words.
Features, my contribution & outcome
My contribution
Connected the trained LSTM, tokenizer, and sequence metadata to a Streamlit application; implemented input validation, CPU inference, cached resource loading, ranked vocabulary decoding, and cloud deployment.
Features implemented
- Partial-sentence input with three ranked next-word suggestions
- CPU inference using the original trained Keras H5 model
- Saved tokenizer with padding and truncation aligned to the model input shape
- Ranked vocabulary predictions with a visible probability distribution
- Cached model resources across Streamlit interface reruns
- Input validation for empty, oversized, and unknown phrases
Engineering challenge
Align inference with the saved model's actual context length, reuse model resources across interface reruns, and make vocabulary limits and prediction probabilities clear to visitors.
Outcome
Delivers the trained sequence model through a browser interface, with three ranked word suggestions and cached CPU inference that reuses model resources across requests.
Project details ↗A full-stack stock analysis portal combining historical prices, 100-day and 200-day moving averages, and estimates from a trained LSTM model. A React dashboard presents model comparisons and error metrics, with authenticated profiles and personal watchlists.
Engineering focus
- Serverless ML inference: Run the trained Keras LSTM weights through batched NumPy inference, keeping the deployed prediction service independent of the TensorFlow runtime.
Features, my contribution & outcome
My contribution
Built the React analysis portal and Django REST API, connected ticker validation and cached market data to trained LSTM inference, and added authenticated profiles and watchlists.
Features implemented
- Ticker-based price history and 100-day / 200-day moving-average charts
- Historical LSTM estimates with MSE, RMSE, and R-squared evaluation
- LSTM-based next-session closing-price estimate
- JWT sign-in, account profiles, and watchlists of up to 10 symbols
- Cached market-data requests and prediction responses
Engineering challenge
Keep price scaling limited to the earlier history segment, batch model inference, and isolate chart rendering while packaging trained weights for serverless execution.
Outcome
Deployed a stock-analysis workflow combining historical charts, trained-model estimates, evaluation metrics, and per-account watchlists.
Project details ↗An AI news reader and personalized newsletter builder collecting OpenAI, Anthropic, and YouTube feeds. OpenAI agents summarize source excerpts, rank stories for a reader’s interests, and produce a source-linked digest for preview, HTML download, or Gmail delivery.
Engineering focus
- Source-aware ingestion: Fetch publisher RSS feeds concurrently, normalize dates and excerpts, deduplicate by URL, and retain cached stories when upstream feeds fail.
Features, my contribution & outcome
My contribution
Built the FastAPI web workflow and reading interface, joined RSS collection to parallel OpenAI summarization and relevance ranking, and added HTML export plus authenticated Gmail delivery.
Features implemented
- Live RSS stories from OpenAI, Anthropic, and YouTube
- Search and source filters with 24-hour, 7-day, and 30-day windows
- Interest-based curation of three-story or five-story digests
- Source-linked summaries with an explanation of each story’s relevance
- Digest preview, copy, HTML download, and owner-authenticated Gmail delivery
Engineering challenge
Preserve source identities and URLs across concurrent feed collection, summarization, and ranking, with cached results and signed previews before email delivery.
Outcome
Deployed a news-to-newsletter workflow with source filtering, personalized digest generation, readable previews, HTML downloads, and owner-controlled email sending.
Project details ↗A healthcare-data explorer connecting patient search, linked records, risk summaries, and database structure. FastAPI exposes read-only SQLite data through four MCP tools, with an OpenAI assistant that discovers and calls those tools.
Engineering focus
- Structured data access: Expose schema discovery, bounded read-only SQL, risk summaries, and readmission queries through four MCP tools.
Features, my contribution & outcome
My contribution
Integrated MCP tools and the bounded OpenAI tool-calling client with a responsive browser explorer, generated SQLite dataset, read-only SQL controls, and Vercel deployment.
Features implemented
- Search and inspect 10 generated patient profiles with linked records.
- Explore rule-based risk summaries and historical readmission indicators.
- Inspect five related SQLite tables in the schema view.
- Four MCP tools expose schema discovery, bounded SQL queries, risk summaries, and readmission insights.
- Authenticated AI requests discover and call the read-only MCP tools.
Engineering challenge
Connecting natural-language questions to structured data while bounding generated SQL, model tool loops, and database access.
Outcome
Makes linked profile records and five related tables accessible through browser search and four structured tools. Read-only SQL controls support schema exploration and source-grounded answers over the generated dataset.
Project details ↗A multi-agent customer-support application that gathers order details, validates tickets, and routes requests to billing or refund specialists. A separate human-review queue resolves eligible refund requests and returns the decision to the customer conversation.
Engineering focus
- Validated routing: Compact multi-turn intake into a Pydantic ticket and route it through LangGraph to deterministic specialists.
Features, my contribution & outcome
My contribution
I integrated conversational intake, structured ticket validation, deterministic specialist tools, a separate approval graph, session resume, Redis admission, and Streamlit Cloud delivery.
Features implemented
- Multi-turn intake compacts conversation details into a validated Pydantic ticket.
- LangGraph routes billing, refund, and general-support workflows.
- Read-only SQLite tools retrieve invoices, payments, and refund eligibility from seeded order records.
- A separate approver view resolves refund-review requests and updates the customer chat.
- Session resume reconnects the customer conversation to its review outcome.
- Upstash Redis enforces admission around requests and model calls.
Engineering challenge
Keeping customer intake responsive while an independent review graph resolves a request and delivers the outcome to the correct conversation.
Outcome
Brings structured intake, specialist routing, invoice lookup, and human review into one workflow. Customers can resume their conversation to see the review decision without restarting intake.
Project details ↗Docwise is a documentation assistant that combines keyword and semantic search to answer technical questions with traceable sources. The hosted Python application fuses BM25 and MiniLM ONNX vector results through reciprocal rank fusion before generating a cited answer.
Engineering focus
- Hybrid retrieval: Fuse BM25 and MiniLM ONNX vector rankings through reciprocal rank fusion before building a source-grounded prompt.
Features, my contribution & outcome
My contribution
I integrated structure-aware ingestion, hybrid retrieval, citation validation, the Docwise browser interface, and a lightweight ONNX deployment for Vercel.
Features implemented
- Two Markdown documents provide 39 heading-aware indexed passages.
- BM25 keyword search and MiniLM ONNX embeddings combine through reciprocal rank fusion.
- Answers include validated source labels and expandable retrieved passages.
- Questions outside the indexed documentation receive an explicit not-found response.
- FastAPI input validation and shared Redis admission control provider requests.
Engineering challenge
Preserving code context during chunking and combining keyword precision with semantic recall while keeping source labels tied to retrieved chunks.
Outcome
Makes 39 passages across two documents searchable through combined keyword and semantic retrieval. Validated citations and inspectable source passages connect answers to the underlying documentation.
Project details ↗A browser-based voice storytelling assistant that turns a spoken idea into a written and spoken adventure. FastAPI coordinates speech transcription, contextual OpenAI generation, and speech synthesis in one asynchronous workflow.
Engineering focus
- Async audio pipeline: Coordinate transcription, contextual story generation, and speech synthesis behind one FastAPI request.
Features, my contribution & outcome
My contribution
I integrated browser audio capture to an asynchronous transcription, generation, and speech playback flow with recoverable errors.
Features implemented
- Browser recording, audio upload, and a built-in recording provide multiple input paths.
- Transcription, contextual reply generation, and speech synthesis run as a staged async workflow.
- Bounded in-memory conversation history supports follow-up turns and session reset.
- Recording duration, file formats, and upload sizes are validated.
- Manual playback supports browsers that restrict audio autoplay.
Engineering challenge
Coordinating three provider stages, committing conversation state only after success, and handling browser recording and autoplay behavior.
Outcome
Connects audio input, transcription, contextual story generation, and playable MP3 output in one interface. Follow-up turns reuse conversation context, with recoverable processing and playback states.
Project details ↗A conversational shopping application connecting product discovery, validated carts, and order summaries. Four Google ADK agents coordinate the conversation while Python controls catalogue prices and totals; Redis restores each browser's shopping session.
Engineering focus
- Agents with deterministic tools: Coordinate four shopping specialists while Python validates catalogue choices, quantities, and totals.
Features, my contribution & outcome
My contribution
I integrated four ADK agents with deterministic catalogue and cart tools, a streamed browser interface, Redis session recovery, and guarded API requests.
Features implemented
- Four specialist agents guide profile collection, catalogue browsing, checkout, and order summaries.
- Python validates products and quantities and calculates cart totals from the catalogue.
- Streamed responses show progress while the assistant completes each turn.
- Redis-backed browser sessions restore the conversation and cart after reload.
- Structured checkout summaries retain the selected products, quantities, and calculated totals.
Engineering challenge
Maintaining consistent state between agent handoffs while ensuring the model cannot invent products, prices, or completed purchases.
Outcome
Connects product discovery, cart calculation, and order-summary preparation in one conversation. Deterministic Python tools keep products, quantities, and totals consistent across agent handoffs, while Redis preserves the cart after reload.
Project details ↗A document-grounded symposium assistant with persistent exact and semantic answer caching. Event-guide questions return page references, while repeated or semantically similar questions can reuse an answer with its original sources.
Engineering focus
- Source-preserving reuse: Check exact and embedding-similarity cache entries before generating a new grounded answer.
Features, my contribution & outcome
My contribution
I integrated PDF retrieval, source-page references, persistent semantic caching, shared request admission, and the deployed browser interface.
Features implemented
- Browser chat answers questions about a symposium PDF with page references.
- OpenAI embeddings and FAISS retrieve guide passages for grounded answers.
- Exact and semantic cache lookups retain the original source references.
- Upstash Redis shares cached answers across serverless requests.
- Request admission, source-index isolation, and controlled errors protect the retrieval workflow.
Engineering challenge
Choosing similarity thresholds and isolating cached answers by source index while keeping the app usable without a Valkey service.
Outcome
Reuses source-grounded answers across repeated questions, avoiding another generation call on a cache hit while retaining the original page references. Persistent Redis storage shares the cache across serverless requests.
Project details ↗A focused PDF question-answering assistant for a symposium guide. A responsive browser chat connects to a FastAPI retrieval service, combining OpenAI answers with inspectable page references for schedules, event rules, and registration.
Engineering focus
- Document retrieval: Ingest the guide separately and retrieve relevant FAISS passages for each question.
Features, my contribution & outcome
My contribution
I integrated PDF ingestion, retrieval, answer generation, page-reference display, public API admission, and Vercel delivery.
Features implemented
- Separate PDF ingestion builds a FAISS index of overlapping source passages.
- Retrieval supplies relevant guide excerpts to the answer prompt.
- Answers show deduplicated source-page references in expandable chat details.
- Index metadata checks help detect a source or embedding mismatch.
- Shared Upstash admission limits requests before provider work.
Engineering challenge
Keeping the vector index aligned with its source document and prompting the model to acknowledge information absent from the supplied excerpts.
Outcome
Turns a five-page guide into a searchable conversation backed by nine indexed passages. Answers connect event schedules, venue details, and registration information to their source pages.
Project details ↗
