Welcome to my space!

I design and build resilient backend systems with a strong focus on microservices and distributed architecture. I also develop AI agents and MCP server-client systems to create intelligent, context-aware applications. This space documents my learning journey through hands-on projects across backend and AI engineering.

• Multi-Agent AI System for Healthcare
• gRPC-based distributed services
• Apache Kafka Streams applications

• Spring Boot Microservices – Spring boot microservices built to understand Spring Cloud Netflix components
• Spring Boot Microservices / Spring cloud v1 – Spring boot microservices built with spring cloud v1 to understand Spring Cloud Netflix components
• Spring Boot Microservices / Spring cloud v2 – Spring boot microservices built with spring cloud v2 to understand Spring Cloud Netflix components

• Spring Web flux – Spring boot project built to understand Spring Web flux and reactive paradigm

• Fast API Service Basics – Fast API project exploring basic of framework
• Fast API Service – A simple Todo Management Application built with FastAPI, SQLAlchemy, and SQLite/PostgreSQL support. It provides authentication, user-specific todo operations, and admin-level controls.
  Project Deployed here - https://todo-app-fexe.onrender.com/

• GraphQL Service – GraphQL Service to understand internal details of GraphQL components and implementing it using spring boot application.
• GraphQL Service Interacting with downstream Services – A Spring boot GraphQL Service that interacts with 3 downstream Services via REST API using Spring Web Client , Aggregates result and returns results based on Graph QL Schema Defination.

• Apache Spark RDD –Implementing Apache Spark jobs using Apache Spark RDD.
• Apache Spark SQL –Implementing Apache Spark jobs using Apache Spark SQL. Dataframe operations.
• Apache Spark Streaming –Implementing data streaming using Apache Spark Stremaing. Includes legacy Spark straming and newer Structured Streaming

• Elasticsearch Spring boot Integration – This project is a hands-on Spring Data Elasticsearch learning POC. It demonstrates how to model Elasticsearch documents, define mappings/settings, run repository and template-based queries, and validate behavior through integration tests.

• MongoDB – Spring boot application to work with MongoDB
• MySQL - Spring boot project to integrate applicatio with multiple DB servers

• Java Project – Java and Apache kafka project
• Java Project v1 – Java and Apache kafka project
• Apache Kafka & spring boot 2.x – Spring boot 2.x and Apache kafka project
• Apache Kafka & spring boot 3.x –Spring boot 3.x and Apache kafka project

• ShedLock – Sring boot service to understand the usage and concepts of distributed locking using shedLock library

• Circuit breaker – Circuit Breakaer implementation using functionl programming & annotations. Includes test cases for circuit breaker and Grafna Dashboards

• Functional Programming – Java project exploring functional Programming
• Multithreading and parallel computine – Java project exploring Multithreading and parallel computine

Problem statement - Not all Spring boot app's execute PostDestroy hook. The Project was built to understand every aspect related to JVM shutdown hook.

• JVM shutdown process – Service to understand relation between k8s pod termination , JVM shutdown using spring boot application. Shows usage of DB spring data jpa without using application.properties

• Reactive Programming – Java project exploring Reactive Programming stack

• GitHub Webhook – Creates a github webhook and process the request. Service is made accessible to github via ngrok or on https://studio.mogenius.com

• Docker Image Internals – React App to understand internals of Docker Image
• Kubernetes - spring cloud v2 – Deploy spring boot microservices with spring cloud v2 on local Kubernetes
• Docker Compose | ZAP scan – Exploring docker compose and genarating ZAP scan report

• AWS Elastic Beanstalk and Travic CI – Deploying a web application on AWS Elastic Beanstalk using Travic CI CI/CD pipeline
• Google Jubernetes Engine and Travic CI – Deploying a web application on Google Jubernetes Engine using Travic CI CI/CD pipeline
• Local K8s cluster deployment – Deploying a the above application on Local K8s cluster deployment
• CI/CD with GitHub Actions | ZAP scan – Built githib action to generate ZAP scan report

• Prometheus & grafana – Spring boot monitoring System using Prometheus & grafana

• Spring Security v1 – Spring boot Security project
• Spring Security v2 – Spring boot Security project
• Spring Security JWT – Spring boot Security project working with JWT tokens

• OPA project with Spring boot – OPA and Spring boot project
• OPA Bundle Service API Demo with Spring boot – Delivering OPA policy bundle using bundle service API [producer and consumer ] using Spring boot project

• ML implementations – Implementing various ML algorithm's using NumPy, Pandas, Matplotlib, Scikit-learn, TensorFlow/Keras, XGBoost, NLTK, Hugging Face Transformers

• Spring AI Agent – Building an AI agent usign Spring AI with tool calling, chat memory, Advisors and RAG flows includes document embedding into qdrant vectore DB . Also underdstanding various prompting techniques using System and User Prompts .

• Human-in-the-Loop Task Planner - AI Agent that has "Human in the Loop" while planning a Task.

  • An AI Agent task planner that combines web Search with a local task database.
  • The key idea is safety: before sensitive actions, a human approves or rejects what the agent wants to do before executing tools thus adding a layer of Human Verification.

• Search Agent – Implementing an Search agent using langchain and tavilySearch Tool. Understanding an agent [model calling tools in a loop until a task is completed ]

• Understading ReAct Agent Internals – Learning LangChain Agent Internals, ie- under the hood working of ReAct LangChain Agent implementing Agent in different ways

  • Implementing ReAct Agent using low level LancChain Objects and couple of defined Tools , [Normal LLM call in loop until the LLM has no Tool invocation in its response ]
  • Implementing ReAct Agent using low level Ollama SDK objects without the use of langChain Objects [Low level Agent implementation without any langChain Tools , with just plain prompting with ollama model]

• Language Translator – Implementing LLM based Language Translator using LangChain, Groq, FastAPI, and LangServe.

• Conversational LLM Assistant with Memory – Conversational LLM Assistant that saves chat history between interactions.

• langchain basics implementation | langchain-basics-v1 – Basic Impl of chat prompt, LLM model and learning core LangChain patterns usage for openAI and olamma models

• ReAct Agent – Implementing ReAct Agent using LangGraph. ReAct Agent - A ReAct agent executes tool calls in a loop until it determines the final answer.

• Reflection Agents – A Reflection Agent built using LangGraph that generates a tweet , self reflects and critiques the generated output and finally provides a better result.

• Reflexion Agent – This project implements a Reflexion Agent using LangGraph, an advanced AI agent pattern that iteratively improves answers through self-critique and web search refinement. The agent generates an initial answer, critiques its own work, performs targeted searches to address gaps, and revises the answer based on new information. This cycle repeats for a configurable number of iterations, resulting in increasingly accurate and well-sourced responses.

• RAG project - Document Assistant –
  • Ingesting LangChain documents into Pinecone Vector DB- Document loading, Test Spiltiing , chunking and generating Embeddings to store in Pinecone DB.
  • Retrval RAG pipeline to answer user query.
  • Demo - https://github.com/yashas224/langchain-doc-assistant/tree/main
• RAG project - multi-URL RAG assistant – A lightweight multi-URL RAG assistant built with LangChain, FastAPI, Chroma, and Streamlit.
  • Accepts one or more web URLs and ingests their page content into a vector database.
  • Answers user questions from uploaded URL, Q&A over the URL contents, with optional source filtering by URL.
  • Maintains chat memory per user session for follow-up questions.
  • Watch the demo
• RAG implementation | RAG-langchain-basics-v1 –
  • Implementing LangChain Core Concepts: Data Ingestion, Embeddings, splitters, vector Storage and Vector Retrieval
  • Static contents are embedded and ingected into Pinecone Vectore Store.
  • Implementing RAG invocation in different ways , using LangChainExpressionLanguage and without LangChainExpressionLanguage.

• Agentic RAG – This project implements an adaptive Retrieval-Augmented Generation flow using LangGraph.

Instead of always doing one fixed pipeline, the graph decides between:

1. Vector store first (RAG path), or
2. Direct web search first

Then it validates relevance, generates an answer, checks hallucination risk, and can loop for retries.

The goal is to improve answer quality by combining:

• Local knowledge from Chroma vector store
• External knowledge from Tavily web search
• LLM-based graders for relevance and grounding checks

• MCP server Remote- Weather server – Remote MCP server that exposes tool to get the weather using api.weatherapi.com.
• MCP server Local- ticketing server –A Customer helpdesk-mcp-server-stdio server that exposes tools to create Tickets for issues raised and retrives them. This is shipped and bundled as a JAR file so that it can be used as stdio MCP server for MCP clients.
• MCP client – AI agent and an MCP client that has the following MCP servers attached:
  • Remote MCP server - Weather server mentioned above via SSE
  • Githib MCP server via STDIO
  • File system MCP server vis STDIO
  • ticketing server mentioned above vis STDIO

• MCP client-Server – A FastAPI-based AI agent host that also acts as an MCP client. It connects to multiple FastMCP servers (math via stdio and web search via HTTP), runs a LangChain agent with conversation memory, and exposes APIs for chat and history.

DEMO - https://github.com/yashas224/mcp-client-server-langchain#product-demo