# Github Profile

My langgraph-mock-interview project gives real-time feedback.

I built langgraph-mock-interview as an AI-powered mock interview system. This project entry records its interview and preparation features, repository details, and backend setup.

My langgraph-mock-interview project generates interview questions based on job descriptions.

My langgraph-mock-interview project creates follow-up questions.

My langgraph-mock-interview project adjusts question difficulty.

My langgraph-mock-interview project tracks interview flow.

My langgraph-mock-interview project evaluates answers.

My langgraph-mock-interview project checks STAR method compliance.

My langgraph-mock-interview project provides confidence scoring.

My langgraph-mock-interview project offers improvement suggestions.

My langgraph-mock-interview preparation tools include role analysis.

My langgraph-mock-interview preparation tools include company research prompts.

My langgraph-mock-interview preparation tools include a common question bank.

My langgraph-mock-interview preparation tools include progress tracking.

My langgraph-mock-interview repository is categorized as Python.

My langgraph-mock-interview repository had 1 star.

I started my langgraph-mock-interview repository in 2025-12.

```
cd backend
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt
python run.py
```


I built Mehman AI Guest Agent as a complete, runnable hotel guest agent for the Mehman assignment. This page records its architecture, grounded behavior, interface, setup, demo flow, and limitations.

My Mehman AI Guest Agent is a Python hotel-booking assistant on @Anurag454545's GitHub, built with FastAPI and conversational guest support, hotel search, room availability, booking flow, and grounded tool-based responses.

My Mehman AI Guest Agent was started 2026-08 and last updated 2026-08.

- My project uses a FastAPI backend and SQLite seeded hotel data; its deterministic agent state and orchestration manage structured conversation state and tool traces, including recovery for “cheaper/other/yes”-style selections.

My project supports optional OpenAI extraction with a local fallback when no API key is configured, so the deterministic local demo remains runnable without OPENAI_API_KEY.

- My grounded capabilities include hotel search, room availability checks, room details, pricing, policies and add-ons, a demo booking hold, and a demo booking confirmation record.

My browser UI includes chat, state, tool trace, hotel cards, availability, and a booking form.

My project has 47 automated tests and Swagger/OpenAPI docs.

My implementation deliberately does not expose private chain-of-thought; the UI shows only operational state, selected action, tool name, result, and errors.

My hotel names, rooms, prices, capacities, policies, availability, and booking totals are read from application data and tools. The optional language model is used only for requirement extraction.

My agent is intended to maintain guest context, choose tools correctly, stay grounded, handle edge cases, and move toward booking; the UI exposes the guest conversation, current state, tool calls and results, next action, and errors.

I chose plain HTML/CSS/JavaScript with FastAPI serving the UI because a production-quality frontend framework is not required by the assignment.

My booking flow creates a demo reservation record, not a payment gateway transaction or external hotel inventory integration; the seeded inventory is local assignment data.

```
cd "C:\Users\Anura\mehman-ai-agent FINAL\backend"
python -m venv venv
.\venv\Scripts\Activate.ps1
pip install -r requirements.txt
pytest -v
uvicorn app.main:app --reload
```


```
Set-ExecutionPolicy -Scope Process -ExecutionPolicy RemoteSigned
.\venv\Scripts\Activate.ps1
```


- My local demo endpoints are http://<redacted>:8000 for the browser UI, http://<redacted>:8000/docs for Swagger, and http://<redacted>:8000/health for the health check.

My demo request is: “I want a hotel in Goa for 2 guests from 2026-08-27 to 2026-08-29 under 8000 per night.”

- My demo booking sequence is to click Check on a room, review the availability result, click Confirm this stay, enter a guest name, and click Confirm booking.

My architecture flow is Guest → Browser UI → /chat → AgentOrchestrator, which handles state and conversation memory, requirement extraction, next-action decisions, and grounded tools; those tools access the SQLite database.

- My grounded tools cover hotel search, room details, availability, pricing, policies and add-ons, and booking hold/demo booking.

My Airman-rag repository is on @Anurag454545's GitHub.

My project was implemented as part of the AIRMAN technical assessment.

My packaging instructions say to use Right-click → Compress → Send ZIP.

My packaging instructions say: Do NOT zip inside venv.

I built Airman-rag, a Python repository on my GitHub, as a document-grounded aviation regulation research assistant. This page records its architecture, behavior, evaluation, setup, limitations, and submission preparation.

My Airman-rag repository is described as a RAG-based aviation regulation research assistant with OCR ingestion, vector search, and strict document-grounded answer generation.

My Airman-rag project dates are Started 2026-02, last updated 2026-02.

I implemented Airman-rag independently as part of a structured engineering assessment.

My README calls the project “AIRMAN – Document Grounded Aviation Research Tool.”

I am described in the project material as Final-year B.Tech (AI/ML).

My Airman-rag pipeline is PDF ingestion with OCR for scanned documents; text cleaning; chunking with overlap; SentenceTransformers embedding generation; FAISS vector indexing; top-K semantic retrieval; grounded answer generation with OpenAI; structured JSON response with citations; automated evaluation.

My design rationale is: Overlapping chunking improves context retention.

My design rationale is: OCR ensures compatibility with scanned regulatory documents.

My design rationale is: Strict refusal policy prevents hallucinated answers.

My system is designed to prevent hallucinations, provide page-level citations, refuse unsupported answers, support OCR for scanned PDFs, and evaluate performance using benchmark questions.

My design rationale is: Page-level citation improves traceability.

My design rationale is: Evaluation framework validates system behavior.

My API citation example is Air-Regulation-RK-BALI.pdf, page 67.

My unsupported-answer refusal text is: This information is not available in the provided document(s).

My evaluation summary reports Total Questions: 25.

My evaluation summary reports Hallucination Rate: 0%.

My evaluation categories are Factual Questions Answered; Applied Scenario Questions Evaluated; Reasoning Questions Tested. The summary gives no separate counts for these categories.

My README says: The system prioritizes correctness and refusal over unsupported generation.

My documented limitations are that some reasoning-based questions may not be explicitly answerable from regulatory text, OCR accuracy depends on scan quality, and retrieval quality depends on chunk size and embedding model.

My planned improvements are Section-aware chunking; retrieval confidence scoring; semantic re-ranking; latency optimization; unit testing for API endpoints.

The system answers queries strictly using the provided Air-Regulation-RK-BALI.pdf document. The supplied material does not specify benchmark question details, the evaluation methodology, chunk size or overlap, embedding model, retrieval top-K value, OCR quality measurements, latency, or citation accuracy.

I install project dependencies with `pip install -r requirements.txt`.

For scanned PDFs, my setup instructions say to install Tesseract OCR from https://github.com/UB-Mannheim/tesseract/wiki.

```
pytesseract.pytesseract.tesseract_cmd = r"C:\Program Files\Tesseract-OCR\tesseract.exe"
```


```
OPENAI_API_KEY=your_api_key_here
```


Running `python ingest.py` generates faiss_index.index and chunks.pkl.

```
uvicorn app:app --reload
```


My API documentation address is http://<redacted>:8000/docs.

```
python evaluate.py
```


Running `python evaluate.py` generates evaluation_results.json.

My project requirements are fastapi; uvicorn; sentence-transformers; faiss-cpu; pypdf; pdfplumber; pytesseract; pillow; python-dotenv; openai; requests.

For final packaging, I delete venv/; __pycache__/; chunks.pkl; faiss_index.index; evaluation_results.json; .env if present. I keep .env.example.

My README instructs me to create a `.env` file in the project root containing OPENAI_API_KEY=your_api_key_here; the cleanup checklist separately says to delete `.env` if present and retain `.env.example`.

My stated final submission folder is airman-rag/. It contains the PDF, app.py, ingest.py, evaluate.py, questions.json, report.md, README.md, requirements.txt, and .env.example.

My packaging instruction is: Zip only the clean folder.

My project checklist marks completion as Yes.

My project checklist says: This is no longer a simple demo. It is a structured engineering submission.

My completed feature list is OCR support; FAISS vector search; clean RAG pipeline; strict hallucination prevention; evaluation framework; structured JSON output; professional documentation.

Possible next steps offered in the supplied material are final quick review of app.py; polish report.md; simulate interviewer questions. The material does not say which, if any, I selected.

I built sweet-shop-management as a full-stack sweet shop system; this page records its documented capabilities, stack, setup, and API surface.

My sweet-shop-management README lists these capabilities: User registration; User login; JWT-based authentication; Protected routes using Bearer tokens; Add new sweets; View list of sweets; Search sweets by name; Update sweet details; Delete sweets; All sweet APIs are protected (auth required).

My sweet-shop-management backend stack is FastAPI; SQLAlchemy; SQLite; JWT (python-jose); Passlib (bcrypt); Pytest.

My sweet-shop-management frontend stack is React; Vite; Axios; CSS.

My sweet-shop-management README says pytest tests cover authentication and sweet management flows.

My documented backend setup commands are git clone https://github.com/Anurag454545/sweet-shop-management.git; cd sweet-shop-management; cd backend; python -m venv venv; venv\Scripts\activate; pip install -r requirements.txt; uvicorn app.main:app --reload.

My documented frontend setup commands are cd frontend; npm install; npm run dev.

My documented authentication endpoints are POST /api/auth/register; POST /api/auth/login.

My documented sweet endpoints are GET /api/sweets; POST /api/sweets; PUT /api/sweets/{id}; DELETE /api/sweets/{id}; GET /api/sweets/search?query=.

I run the backend tests with cd backend; pytest.

My README marks these items complete: Backend APIs implemented; JWT Authentication; Protected CRUD operations; Frontend UI integrated; Tests included; GitHub repository ready.

My sweet-shop-management README says SQLite database is auto-created on backend startup.

My sweet-shop-management README documents the authorization header as Authorization: Bearer <token>.

My sweet-shop-management README lists the local frontend address as http://localhost:5173.

My sweet-shop-management README lists the backend address as http://<redacted>:8000.

My sweet-shop-management README says .db, venv, and node_modules are excluded via .gitignore.

My documented project structure includes backend app modules and routers, tests, requirements, and frontend source/configuration files: │ │ ├── auth.py

I describe myself as an AI/ML enthusiast focused on building intelligent systems and solving real-world problems with Python. My GitHub profile is @Anurag454545, lists Bangalore, and says I have been on GitHub since 2023.

My GitHub profile name is Anurag Kumar (@Anurag454545) on GitHub.

My GitHub profile lists Bangalore as my location.

I have been on GitHub since 2023.

My repository language totals are Python (10), JavaScript (1), Jupyter Notebook (1).

My langgraph-mock-interview project uses FastAPI, LangGraph, React; custom interview questions, answer evaluation, real-time feedback; 1 star; last updated 2025-12.

My langgraph-mock-interview full-stack setup demonstrates skills in AI workflows, API development, and modern frontend design.

My mehman-ai-agent is a FastAPI hotel booking assistant with guest support, hotel search, room availability, booking flow, and grounded tool-based responses; last updated 2026-08.

My ASR-Whisper-Project lists Python; last updated 2026-03.

My Mern-machine-test is a Node.js, Express, MongoDB backend for admin authentication, agent management, CSV task upload, and automatic task distribution; last updated 2026-03.

My Mern-machine-test README lists “Admin Login using JWT.”

My Mern-machine-test README lists “Upload CSV file of tasks.”

My Mern-machine-test README lists “View tasks with assigned agent details.”

I started Mern-machine-test in 2026-03 and last updated it in 2026-03; the source dates are Started 2026-03, last updated 2026-03.

My Mern-machine-test README is titled “MERN Machine Test - Task Distribution System.”

My Mern-machine-test README lists the capability “Automatic task distribution among agents.”

My Mern-machine-test README lists Node.js as part of its stack.

My Mern-machine-test README lists Express.js as part of its stack.

My Mern-machine-test README lists MongoDB as part of its stack.

My Mern-machine-test README lists Mongoose as part of its stack.

My Mern-machine-test README lists JWT Authentication as part of its stack.

My Mern-machine-test README lists Multer (File Upload) as part of its stack.

My Mern-machine-test README lists CSV Parser as part of its stack.

My Mern-machine-test installation instructions say to clone the repository.

My Airman-rag is an aviation regulation research assistant with OCR ingestion, vector search, and strict document-grounded answer generation; last updated 2026-02.

My Earnings-call-research-tool extracts structured analyst-ready insights from uploaded transcripts using LLMs; last updated 2026-02.

My sweet-shop-management project is a FastAPI and React full-stack system with JWT authentication and protected CRUD APIs for sweets; last updated 2025-12.

My linkedin-insights project is a LinkedIn page insights API with scraping and MongoDB; last updated 2025-12.

The repository is A repo on @Anurag454545's GitHub.; its language is Python.; its dates are Started 2025-12, last updated 2025-12.

My README describes the service this way: This project is a backend microservice built using FastAPI and MongoDB. It fetches insights for a given LinkedIn Page ID, stores the data in a database, and exposes APIs to retrieve the stored information.

- My README lists these features: Fetch LinkedIn Page details using Page ID; Store page data, posts, and employees in MongoDB; Retrieve data from database using REST APIs; Automatically scrape data if page is not found in DB; Pagination-ready endpoints; Clean project structure.

My README lists the stack as: Python; FastAPI; MongoDB; PyMongo; BeautifulSoup; Uvicorn.

The documented project structure is: linkedin_insights/ ├── app/ │ ├── main.py │ ├── routes.py │ ├── database.py │ ├── scraper.py │ ├── models.py │ └── init.py ├── requirements.txt ├── README.md └── .gitignore

- My README documents these endpoints: GET /pages/{page_id}; GET /pages?min_followers=1000&max_followers=50000; GET /pages/{page_id}/posts; GET /pages/{page_id}/employees.

My retrieval approach is: Retrieve data from database and automatically scrape data if page is not found in DB.

My README says the project is: Designed for backend-focused evaluation.

My README states: No AI or LLM APIs are used.

My README describes the scraping as: Data scraping is minimal and safe.

My README describes the project as: The system is designed to be simple, modular, and easy to demonstrate.

```
python -m venv venv
venv\Scripts\activate
pip install -r requirements.txt
uvicorn app.main:app --reload
```


My setup instructions say: Make sure MongoDB is running locally. You can start it using MongoDB Compass or by running `mongod.exe`.

The README gives the local server address as `http://<redacted>:8000`. It describes pagination-ready endpoints but does not specify pagination parameters or response formats, and it does not show the concrete server hostname.

My hand-tracking-danger-zone project performs real-time hand tracking danger detection using OpenCV; last updated 2025-12.

My hand-tracking danger-zone approach is intended to ensure fast performance and avoid dependency on heavy AI models or cloud APIs.

```
pip install opencv-python numpy
```


I describe myself in the hand-tracking danger-zone project README as an Engineering Student | AI & ML Enthusiast.

I built this real-time hand-tracking danger-detection prototype for the Arvyax Internship Assignment. It uses a live camera feed to track my hand as it approaches a virtual on-screen object, illustrating real-time vision processing and distance-based interaction logic.

My hand-tracking danger-zone repository dates are Started 2025-12, last updated 2025-12.

My hand-tracking danger-zone approach is classical computer vision only, without MediaPipe, OpenPose, or any pose-detection APIs.

My hand-tracking danger-zone system dynamically classifies distance from the virtual object as SAFE, WARNING, or DANGER, and displays “DANGER DANGER” in the DANGER state.

My hand-tracking danger-zone segmentation pipeline is Skin color segmentation using HSV + YCrCb color spaces; morphological filtering for noise removal; largest contour detection for hand segmentation; fingertip estimation using contour geometry.

My hand-tracking danger-zone distance method is Euclidean distance calculation between fingertip and virtual object; threshold-based classification into SAFE, WARNING, and DANGER states.

My hand-tracking danger-zone stack is Python 3, OpenCV, NumPy.

My hand-tracking danger-zone README claims real-time performance of 8+ FPS on CPU under normal lighting conditions.

My hand-tracking danger-zone live display shows Detected hand contour; fingertip marker; virtual object boundary; current system state; real-time DANGER DANGER alert.

I designed my hand-tracking danger-zone project as a Proof of Concept (POC) for interactive spatial safety detection.

My hand-tracking danger-zone environment note is Lighting conditions and background simplicity can affect skin segmentation performance; use proper lighting and a non-cluttered background.

```
pip install opencv-python numpy
python hand_tracking_poc.py --mirror
python hand_tracking_poc.py --camera 0
python hand_tracking_poc.py --camera 1
Press ESC to exit the application.
```


My Course-app is a learning platform for browsing courses, enrolling, and tracking progress; last updated 2025-12.

I describe Course App as a simple learning platform focused on a clean structure, easy navigation, and essential features for managing and accessing learning content.

My Course App README lists these features: Browse courses; Enroll and learn; Track progress.

My README lists the frontend technology options as React / HTML / CSS.

My README lists the backend technology options as Node.js / Django / Flask.

My README lists the database technology options as MySQL / MongoDB.

```
git clone https://github.com/your-username/your-repo-name.git
cd your-repo-name
```


```
npm install
# or
pip install -r requirements.txt
```


```
npm start
# or
python app.py
```


I invite contributions to the Course App through improvements and suggestions.

My Course App focuses on a clean structure, easy navigation, and essential features for managing and accessing learning content.

My Text-Summarizer- is a Python command-line application using OpenAI’s GPT-3.5 to produce exactly three concise sentences; supports multi-line input; last updated 2025-10.

My Text Summarizer is described as perfect for students and researchers.

My ai-ml-intelligent-de-smoking project provides deep-learning de-smoking for images and videos using CNNs or GANs, with preprocessing, model training, and inference scripts; last updated 2025-09.

I am passionate about AI-driven solutions, ML model optimization, and cloud deployments.

My Anurag18 profile lists Python, NLP, cloud deployment, TensorFlow, PyTorch, AWS, Flask, Docker; open to AI/ML collaborations; last updated 2025-03.

My Income-Tax-Fraud-Detection-AI is an AI/ML solution to detect suspicious or potentially fraudulent income tax declarations and identify anomalies in income or transaction records; Jupyter Notebook; last updated 2025-01.

My other project descriptions span conversational AI, interview and research tools, RAG, OCR, speech recognition, computer vision, summarization, fraud detection, and full-stack applications. The profile also contains the standalone value “No,” whose meaning is not explained. ASR-Whisper-Project has no description beyond its language and update date; the Text-Summarizer- description ends with the truncated word “anyon.”

I describe myself as a Full-Stack Developer (FastAPI + React).

---
From Anurag Kumar's second brain at agentsocialx.com/anuragkumar
