Sakshi Bagul
AI & ML Engineer | LLM Agents, RAG, Computer Vision
- 1
- Followers
AI Agent for ServiceNow Automation (LangGraph + GPT-4o-mini + Slack, Jira, Email)
I built a LangGraph agent that turns natural-language requests into ServiceNow incidents, so users never have to open the ServiceNow UI. A StateGraph workflow pairs an LLM node (GPT-4o-mini) that understands the request with a tool node that runs the ServiceNow Table REST API. It supports caller, description, and assignment group fields, and it resolves group names to sys_ids by looking them up in the sys_user_group table, so users can just say “Network Team”. The agent is exposed through a Flask REST endpoint and an interactive CLI, with credentials kept in environment variables and error handling around every API call. I then extended the same pattern to Slack, Email, and Jira to automate workflows across platforms.
Understand: The LLM node interprets the request and extracts the caller, description, and assignment group.
Act: The tool node executes ServiceNow actions through the Table REST API.
Resolve: Group names are looked up in the sys_user_group table to get the sys_id, so users refer to teams by name.
Expose: A Flask REST endpoint and an interactive CLI give two ways to use the agent.
Secure and robust: Credentials are managed through environment variables, and API calls have error handling.
Extend: The same agent pattern was reused for Slack, Email, and Jira integrations.
Tools to tag
Python, LangGraph, OpenAI GPT-4o-mini, Flask, ServiceNow REST API, Slack API, Jira, Agentic AI, Automation
2
2
57
Agentic RAG for Document Processing (LangChain, LangGraph, Docling + Qdrant)
I built an end-to-end Agentic RAG pipeline that turns unstructured documents into accurate, context-aware answers. Docling extracts structured content while preserving the original layout, so tables and images stay in place. The content is converted to Markdown, split with recursive chunking into context-preserving chunks, embedded with MPNet, and stored in Qdrant with metadata. LangChain handles retrieval and LangGraph orchestrates the agentic workflow, which fetches the right context for each query using semantic search plus metadata filtering. Redis session memory keeps conversations coherent. Optimizing parsing, chunking, embeddings, and retrieval raised retrieval accuracy from 40–50% to 90–95%.
Document parsing: Docling extracts structured data from documents and keeps tables and images where they belong, instead of displacing them.
Chunking: Content is converted to Markdown with LlamaIndex MarkdownNodeParser, then split with recursive chunking so each chunk keeps its context.
Embedding and storage: The MPNet embedding model creates vectors from the chunks, which are stored in Qdrant along with metadata.
Retrieval: Semantic similarity search is combined with metadata filtering to fetch the most relevant context.
Agent orchestration: LangGraph builds the agentic workflow, with LangChain handling retrieval and LLM calls. The agent decides what to retrieve for each user query.
Memory: Redis-based session memory carries conversational context across the workflow.
Answering: An LLM uses the retrieved context to give grounded, accurate responses.
Tools to tag
Python, LangChain, LangGraph, LlamaIndex, Docling, Qdrant, MPNet Embeddings, Redis, RAG, Agentic AI, LLMs, Document Processing
1
30
Figma Design to Test Cases, Automatically (Figma MCP + Qwen Vision + Qdrant RAG)
I built an AI-first pipeline that turns a Figma design file into test cases automatically. Design images and JSON are pulled through Figma MCP in batches of 50, with a leaky-bucket rate limiter to stay within API limits. A fixed-schema parser reduces the huge Figma JSON to what matters: screens, dropdowns, hover states, and navigation edges (source to destination). Each screenshot and its JSON slice go to Qwen vision on Groq, which writes a rich summary of the screen. Every screen becomes a chunk in Qdrant, plus one extra chunk for the full end-to-end flow. At query time, metadata search routes each request to exactly the chunks it needs.
Extract: Access token and file ID go through Figma MCP, which returns images and JSON in batches of 50. A leaky-bucket rate limiter keeps requests smooth and rate-limit safe.
Parse: The raw Figma JSON exceeds the LLM context window, so a fixed-schema parser pulls out only the useful parts: dropdowns, hover states, and navigation edges (for example, Search → Product on a result card click).
Understand: Each screen’s screenshot and JSON slice go to Qwen vision on Groq, which produces a detailed summary of the screen, its dropdowns, and its interactions.
Chunk and store: Every screen becomes a chunk in Qdrant, holding the summary, JSON, and metadata (screen_id, flow, source → destination), plus one full-flow chunk (-1).
Retrieve by intent: Metadata search decides what to fetch. For example, “end-to-end test cases” fetches the full-flow chunk, “Login → Search product” fetches only that screen range, and a query with no scope is processed batch by batch.
Generate: The retrieved context is used to generate test cases.
Tools to tag
Python, Figma MCP, Groq, Qwen Vision, Qdrant, RAG, Multimodal LLMs, Kafka, Rate Limiting, Test Automation, Generative AI
0
18
AI-Powered Video Processing Pipeline (Vision-LLM + Kafka + FastAPI)
I built an end-to-end pipeline that turns an uploaded video into searchable, summarized knowledge. Videos are pulled from S3 and sampled at 1 frame per second with OpenCV. Blank videos are rejected early with a pixel-variance check. Frames are sent in batches of 500 to a Vision LLM, which describes each batch. In parallel, FFmpeg extracts the audio and Whisper turbo on Groq transcribes it. gpt-oss-120b then combines the batch notes and the transcript into one end-to-end summary, and everything is stored in Qdrant for semantic search. Kafka and FastAPI run the jobs asynchronously, so large uploads never hit HTTP timeouts.
Ingestion: The frontend uploads the video to Amazon S3. A FastAPI endpoint publishes a job to Kafka and returns immediately, and a consumer downloads the video with boto3.
Visual path: OpenCV samples 1 frame per second. A blank-frame check (standard deviation below 3) terminates invalid input early. Valid frames are Base64-encoded in batches of 500, and a Vision LLM describes each batch.
Audio path: FFmpeg extracts the audio track, and Whisper turbo on Groq converts speech to text.
Synthesis: gpt-oss-120b on Groq merges all batch notes and the transcript into a single summary of the whole video.
Storage: The batch notes and the final summary are stored in Qdrant, so the video’s content can be searched and used in RAG workflows.
Tools to tag
Python, FastAPI, Kafka, OpenCV, FFmpeg, Amazon S3, Whisper, Groq, OpenAI, Qdrant, Vision LLM, RAG
0
20