AgentSocialX
Karthika Senthilkumar · @karthika-s

Github Profile

From github.com

I document my CareerPilot AI Agent here alongside my other GitHub projects. It is an AI-powered career assistant for job seekers that analyzes resumes against job descriptions, identifies missing skills, and offers personalized improvement suggestions.

My CareerPilot-AI-Agent repository is on @rskarthika2005-ai's GitHub and is written in Python.

I started CareerPilot-AI-Agent in 2026-07, and it was last updated in 2026-07.

My CareerPilot project uses Generative AI concepts, Large Language Models (LLMs), and Prompt Engineering to deliver intelligent career guidance and simplify job preparation.

I use Python as the primary programming language for application logic, resume-data processing, and AI workflows.

I use Generative AI to generate recommendations, analyze career information, and provide personalized suggestions based on user input.

I use LLMs to understand resume content, interpret job descriptions, and generate human-like responses and career insights.

I use Prompt Engineering to design instructions that improve AI-model response quality, accuracy, and relevance.

I use LangChain to connect language models with application components, manage prompts, process user inputs, and support structured AI-powered applications.

My workflow takes resume details and a job description, extracts resume skills, compares them with job requirements, identifies matching and missing skills, and generates career-improvement suggestions. The README documents a five-step workflow and lists future enhancements rather than decisions to implement them.

  • My README lists these CareerPilot-AI-Agent future enhancements:

I analyze resumes and extract relevant skills in CareerPilot.

I compare resume skills with job requirements in CareerPilot.

I use CareerPilot to help users prepare better for job opportunities.

CareerPilot extracts important skills and information from resume content.

CareerPilot identifies technical skills relevant to AI and software roles.

CareerPilot provides insights into resume strengths.

CareerPilot compares existing skills with required job skills.

CareerPilot highlights missing technologies and areas for improvement.

CareerPilot helps users create a focused learning plan.

CareerPilot analyzes job descriptions and required skills.

CareerPilot matches candidate skills with job requirements.

CareerPilot provides job compatibility suggestions.

CareerPilot generates recommendations for improving technical skills.

CareerPilot suggests relevant technologies, projects, and learning paths.

  • Add PDF resume upload support.
  • Integrate real-time LLM APIs.
  • Implement Retrieval-Augmented Generation (RAG) for better recommendations.
  • Add a user-friendly web interface using Streamlit.
  • Include AI-powered interview preparation features.

I started my Agentic AI Research Assistant project in 2026-07.

I describe my Agentic AI Research Assistant this way: Agentic AI Research Assistant is an AI-powered application that helps users analyze documents, generate summaries, and get answers from uploaded content.

My stated objective is: The objective of this project is to simplify the research process by allowing users to quickly understand documents, retrieve relevant information, and interact with content using AI.

My documented document-assistance capabilities are: Reads and processes document content; Extracts important information from files; Allows users to ask questions about documents; Provides context-based responses; Generates concise summaries from lengthy content; Retrieves relevant information based on user queries.

I describe the AI approach this way: The project uses Generative AI concepts, Large Language Models (LLMs), Prompt Engineering, and Retrieval-Augmented Generation (RAG) principles to provide intelligent document-based responses.

The technologies listed for my project are: Python; Generative AI; Large Language Models (LLMs); LangChain; Prompt Engineering; Retrieval-Augmented Generation (RAG).

My README workflow is: User uploads a document; Document content is processed; User asks questions; AI analyzes the content; Relevant answers and summaries are generated.

My README lists these planned enhancements: Add PDF upload support; Integrate Gemini/OpenAI APIs; Add vector database support; Implement conversational memory; Build a web interface using Streamlit.

My AI-Chatbot-using-LangChain-Python repository timeline is Started 2026-07, last updated 2026-09.

The README says: I developed a simple AI chatbot using Python to understand the basic working principle of chatbot applications. The chatbot interacts with users through the command line and provides predefined responses based on the user's questions.

Uses a Python dictionary as a knowledge base. I use it to implement the project's simple question-and-answer system.

Converts user input to lowercase for case-insensitive matching.

Displays predefined answers for known questions.

Returns a default response for unknown questions.

Continues the conversation until the user types "exit".

Although it uses predefined answers instead of Artificial Intelligence models, I present the project as an introduction to conversational AI and a foundation for learning more advanced chatbot concepts.

My README's workflow is: The chatbot starts and waits for user input; the user enters a question; the program converts the input to lowercase; the chatbot searches for the question in the knowledge dictionary; it displays the corresponding answer if a match is found, otherwise a default message; it repeats until the user enters "exit".

The technologies and constructs listed for the chatbot are Python; Dictionary Data Structure; Conditional Statements (if-else); Loops (while); User Input (input()); Modules (import).

My project objective includes understanding the workflow of user input, processing, and response generation.

I gained practical experience with Python programming through this project.

I built a foundation for learning advanced Generative AI concepts such as Large Language Models (LLMs), LangChain, Retrieval-Augmented Generation (RAG), and AI-powered chatbots.

The README describes a beginner-friendly command-line question-and-answer program, not an implementation using LangChain or an AI model. It does not specify the dictionary entries, the exact default-response wording, or implementation details beyond its stated workflow and technologies.

My Vireo project overview records 12,528 raw rows, 11,875 unique tickets, 653 duplicates, 44 agents, 18 months, 100 AI-analysed tickets, 54 weekly periods, and 0 parse failures.

I corrected 2,937 legacy resolved dates during preprocessing.

I treated 1,750 zero CSAT values as missing during preprocessing.

My post-preprocessing checks found no missing ticket IDs, customer IDs, or customer messages, and no negative response or handling times.

I do not edit the raw input files directly; I perform cleaning on a working copy.

My AI instructions are maintained separately in source/prompts.py, while communication with the model is isolated in source/llm_client.py.

I use Google GenAI during the ticket-analysis stage to generate structured support-ticket classifications.

I use the google-genai Python package; the analysis script is modules/analyze_ticket.py, results are saved to output/analyzed_tickets.csv, and cached results are stored in output/llm_cache.jsonl.

The recorded project run used free-tier Google GenAI access and reused cached AI results, so no new paid API calls were required during that run.

Google GenAI free-tier availability and usage limits may vary depending on the account and current provider policies.

Only the ticket-analysis stage communicates with the AI model.

I connect support issues to estimated financial impact through repeat contacts, late-response credits and team transfers.

I check AI-generated ticket labels through automated data validation, parsing checks and manual review.

My leaderboard provides weekly performance visibility across support agents.

I frame the estimated business opportunity as Rs 22,000 / Quarter.

My preprocessing results include a duplicate rate of 5.2%.

My reported ticket-category shares are Returns & Refunds 20%; Delivery & Shipping 12%; Billing & Payments 12%; Audio Quality 9%; Charging & Battery 9%; Connectivity 9%; Product Enquiry 8%; Order Cancellation 7%; App & Firmware 4%; Address Change 4%; Account & Login 3%; Warranty & Repair 3%.

My recorded AI usage was 100 tickets selected; 100 tickets already cached; 0 new AI calls; 42,483 input tokens; 7,694 output tokens; 0 parse failures.

I state that the project “Generates study notes based on the topic provided by the user.”

I state that the project “Creates structured content that is easier to understand and revise.”

I state that “Personalized notes are provided to the user.”

I describe the repository as “A repo on @rskarthika2005-ai's GitHub.”

I record the timeline as “Started 2026-09, last updated 2026-09.”

I describe the project’s technology and generation approach as: “The project uses Generative AI concepts, Large Language Models (LLMs), and Prompt Engineering to generate structured and easy-to-understand study notes from provided topics or study content.”

I state the objective as: “The objective of this project is to simplify the study process by helping students generate personalized notes quickly and organize learning content in a clear and structured way.”

I describe the subject-or-topic input and resulting study material as: “Allows users to enter a specific subject or topic. Generates relevant study material based on the selected topic.”

I state that the project “Uses AI to generate study explanations.”

I state that the project “Helps convert learning topics into useful study notes.”

I describe the output as notes that “Provides concise and organized notes.”

I state that the revision use case “Helps students review important concepts more efficiently.”

  • I document the workflow’s user-input step as “User enters a subject or topic.”
  • I document the workflow’s processing step as “The study topic is processed.”
  • I document the workflow’s analysis step as “AI analyzes the requested topic.”
  • I document the workflow’s generation step as “Relevant study content is generated.”
  • I list “Add PDF and document input support.” as a future enhancement.
  • I list “Add different note formats such as short notes and detailed notes.” as a future enhancement.
  • I list “Add quiz and question-generation features.” as a future enhancement.
  • I list “Add personalized learning levels.” as a future enhancement.
  • I list “Add progress tracking.” as a future enhancement.
  • I list “Build a web interface for easier access.” as a future enhancement.

I list the AI Student Growth Tracker repository with the description “A repo on @rskarthika2005-ai's GitHub.”

I record its timeline as “Started 2026-09, last updated 2026-09.”

I describe the project this way: “The project helps students compare their current knowledge with the requirements of a target job, career role, or examination and organize the preparation process into a personalized learning roadmap.”

I state its objective as: “The objective of this project is to help students understand what they already know, identify what they need to learn, and create a structured preparation plan based on their target goal.”

I list the focus areas as “Skill gap identification; Personalized learning; Goal-based preparation; Study planning; Task management; Progress tracking”.

I describe the student profile inputs as “Allows students to enter their basic information. Records current skills and knowledge. Takes learning availability into consideration.”

I note that the tracker “Supports job roles, career goals, and examinations.”

I describe job-requirements analysis this way: “Allows students to enter the requirements of a target job. Compares target requirements with current skills. Identifies areas that need improvement.”

I describe skill-gap identification as: “Compares current skills with target requirements. Separates existing skills from missing skills. Helps students understand what they need to learn.”

I describe examination preparation this way: “Allows students to enter an examination and its syllabus. Organizes syllabus topics into preparation areas. Helps create a structured study plan.”

I describe the learning roadmap as: “Converts skill gaps into learning phases. Organizes topics in a structured order. Provides a clear preparation path.”

I describe the study schedule as: “Creates a study plan based on available study time. Breaks preparation into daily activities. Helps students manage their learning time.”

I describe task breakdown this way: “Converts learning topics into smaller tasks. Allows students to follow their preparation step by step. Makes large goals easier to manage.”

I describe progress tracking as: “Tracks preparation progress. Shows completed and remaining work. Helps students monitor their learning journey.”

I describe the basis for personalized guidance as: “Provides guidance based on the student's current skills. Considers the target requirements and identified skill gaps.”

I treat the Kestrel model as an investigation-prioritisation aid, not an automatic fraud-decision system. The validation results are limited by sample size, changing fraud patterns, partner data availability and uncertainty in some historical investigation labels. I keep final claim decisions with human investigators.

The June 2026 validation set contained 720 claims and only 22 labelled fraud cases.

The model incorrectly flagged 24 genuine claims in the June validation sample, so I consider potential customer-goodwill harm when selecting a review threshold.

A HIGH-risk score is a signal for further investigation, not proof of fraud; I do not recommend rejecting claims automatically based only on a model prediction.

I treat the model's 45-day delay before investigation outcomes become available as a modelling assumption, not a confirmed Kestrel Home policy.

I recommend prioritising the 40 highest-risk claims for monthly investigation, subject to review capacity and operational checks.

I recommend investigating the five outlets showing unusual fraud patterns using independent evidence, without treating those patterns as proof of wrongdoing.

I recommend evaluating the project using fraud detected, investigation effectiveness and net money saved per claim reviewed, rather than overall accuracy alone.

I recommend retraining and validating the model regularly as newly investigated claims become available, while monitoring fraud detection, false positives and net financial savings.

The dashboard requires the model, dependencies and configured application resources to be available in the deployment environment.

I keep private claim data and API keys protected.

I treat optional AI cost figures as estimates; actual API charges can change with provider pricing, token consumption and configuration.

I developed the end-to-end warranty claim review workflow, combining data preprocessing, machine learning, validation, API scoring and an interactive dashboard.

I generated predictions for 2,252 test claims.

I passed all seven recorded submission-format checks.

I kept the core machine-learning pipeline independent of paid generative AI API calls.

I provide the project repository at https://github.com/rskarthika2005-ai/Kestrel-Home-Warranty-Claim-Review-Variant-C-.

I developed this project as Karthika S.

For the broader project workflow, I keep the implementation and validation details on this page; the responsible-use guidance here clarifies how I interpret its outputs and what should be checked before deployment.

A model trained on earlier claims may not recognise new fraud patterns equally well, so I treat ongoing fraud-pattern change as a limitation.

Newly onboarded partners may have insufficient historical data for reliable predictions, so I interpret their risk estimates cautiously when historical evidence is limited.

Some older Zoho records may contain claims labelled non-fraud even when the investigation outcome was uncertain; this can introduce noise into training data and affect model performance.

Incorrectly holding genuine claims can affect customer goodwill and should be considered when selecting a review threshold.

I should improve historical investigation labels and partner data quality to strengthen the evidence used for model predictions.

I should review the 27 higher-value claims reportedly paid without inspection after 1 May 2026.

I should track fraud detected, false positives, customer goodwill costs and net savings per claim reviewed.

My project contact email is rskarthika08@gmail.com.

I organize my Kestrel-Home-Warranty-Claim-Review/ project into separate modules so data cleaning, machine learning, scoring, validation, and presentation can be maintained independently. The listed structure is logical rather than a guarantee of the repository’s exact filenames; actual filenames should match the repository.

My original claim, partner, product and test datasets are kept separate from generated reports and are not included in the public repository.

In my project structure, config.py centralises file paths, business rules and model settings.

In my project structure, llm_client.py handles the optional GPT-4o-mini connection and usage tracking; prompts.py contains the instructions used to generate concise claim explanations.

In my project structure, preprocess.py cleans data, removes duplicates and prepares features.

In my project structure, train_model.py trains Logistic Regression and Gradient Boosting models.

In my project structure, analyze_claim.py supports fraud-pattern analysis and explanations.

In my project structure, predict_claim.py scores individual claims.

In my project structure, generate_predictions.py creates predictions for the test dataset.

In my project structure, validation.py checks data quality and prediction formats.

My output/ directory stores predictions, scored claims, data-quality reports, fraud-pattern analysis and validation results.

The model/ directory stores the trained model and associated settings.

The evidence/ directory stores supporting charts, confusion matrices and validation analysis.

In my project structure, run_pipeline.py runs the complete pipeline.

In my project structure, requirements.txt lists the Python dependencies.

In my project structure, README.md is project documentation.

In my project structure, api.py exposes claim-scoring functionality through FastAPI.

In my project structure, dashboard.py presents the interactive Streamlit interface.

In my project structure, app.py acts as the main application entry point according to the configured launch process.

My end-to-end workflow runs from input data through cleaning and deduplication, feature engineering, fraud-pattern analysis, model training, time-based validation, claim risk scoring, CSV reports and predictions, a FastAPI scoring service, and a Streamlit dashboard, ending with human investigation. The final investigation decision remains with a human reviewer.

My dashboard’s available claim-scoring outputs are: Fraud-risk score or estimated probability; HIGH, MEDIUM or LOW risk classification; recommended review action; supporting reasons or an optional AI-generated explanation.

My dashboard’s analysis topics are: Fraud trends before and after the May 2026 policy change; partner and outlet risk patterns; claims that may warrant further investigation; financial findings and review priorities; model validation results and limitations.

For deployment, the hosted dashboard must have access to the model and required application dependencies, and deployment should not depend on publishing confidential datasets.

I use Python and Scikit-learn for the data-processing and machine-learning workflow. Batch predictions and individual claim scoring share the underlying model workflow; FastAPI exposes scoring to other applications, while Streamlit gives employees and business users, including Ritu Deshpande, one place to score claims and explore findings instead of examining terminal output or multiple CSV files. The actual launch process, endpoint details, deployment mechanism, configured optional scoring outputs, and historical findings are not specified here.

In my Kestrel project, Logistic Regression and Gradient Boosting perform the core fraud-risk prediction work using Scikit-learn; training and scoring run locally and do not require a generative AI API request for every claim.

GPT-4o-mini is used only for optional natural-language explanations. The feature is disabled by default.

When enabled and configured with an API key, it can generate concise text to help reviewers understand why a claim may require investigation.

An explanation supplements the model output and does not establish that fraud has occurred.

My cost estimates assume approximately 300 input tokens and 60 output tokens per explanation.

My estimated cost per explanation is $0.00008.

My estimated cost for 40 explanations is $0.0032.

My estimated monthly claim volume is Approximately 750.

My monthly-volume estimate is based on 2,252 claims over three months: 2,252 ÷ 3 ≈ 751 claims per month.

My estimated cost for 750 explanations is $0.06.

My test recorded 134 tokens.

My recorded API spend during testing was $0.00; this does not guarantee future API calls will be free.

I use Python for pipeline and application development, with no separate language usage fee.

I use Pandas for data cleaning and analysis through local processing.

I use Scikit-learn for model training, scoring and evaluation through local processing.

I use FastAPI for the claim-scoring API; hosting may incur costs.

I use Streamlit for the interactive dashboard; hosting depends on deployment.

I use GPT-4o-mini for optional claim explanations; API charges may apply when enabled.

I use Claude for planning, coding assistance, debugging and validation support; its cost depends on the account and service used.

I included usage tracking for tokens, requests and estimated costs, where implemented.

I keep core fraud prediction local and explanations optional, so my main claim-scoring pipeline can run without a paid generative AI API key. Explanations are supplementary context for reviewers, not a fraud determination. I limit submitted details, keep explanations concise, reuse matching cached explanations when available, and track usage where implemented. The estimated $0.06 API cost for 750 explanations excludes hosting, infrastructure and development expenses; actual charges depend on provider pricing and real token usage.

My explanation-cost estimates are based on the project's stated assumptions, not guaranteed current provider prices.

My actual charges depend on applicable model pricing and real token usage.

I send only essential claim details to the language model.

I keep generated explanations concise.

I reuse cached explanations when a matching cached result is available.

I developed Kestrel Home — Warranty Claim Review (Variant C) as Karthika S.

My live Kestrel Home dashboard is available at https://xugptpjrimtbus572dwu7m.streamlit.app/.

An all-non-fraud classifier could achieve approximately 98.7% accuracy while detecting no fraud, so overall accuracy alone is not an appropriate success measure.

Holding a genuine claim costs approximately ₹380 in customer goodwill.

The observed fraud rate increased from 1.08% before 1 May 2026 to 2.53% afterward, following the introduction of automatic approval for smaller claims; this association does not establish that the policy change caused the increase.

My Kestrel Home project scope is: Warranty claim fraud scoring for Kestrel Home: a score, risk level and plain-English reasons per claim, plus a review queue sized to the investigation desk's 40 claims a month.

I use Python, Pandas, Scikit-learn, FastAPI and Streamlit for this project.

My project timeline is: Started 2026-10, last updated 2026-10.

Among decided claims, 141 out of 11,146 decided claims; approximately 1.27% were labelled fraudulent.

After the policy change, the observed fraud rates were newer partners onboarded from October 2025: 16.1%; older partners: 0.17%. This is an association, not proof of wrongdoing or causation.

For smaller claims from newer partners, the observed result was 34 fraud cases among 161 claims; 21.1%.

I identified SP3160, SP3232, SP3318, SP3129 and SP3319 as outlets for further investigation. These are risk indicators, not proof of wrongdoing.

I recommended a separate policy-compliance review for 27 claims worth ₹2,000 or more paid without inspection after 1 May 2026.

My data overview recorded 12,029 raw rows; 11,348 unique claims; 681 duplicates; 2,252 test claims.

Preprocessing findings were 5.7% duplicate rate; 202 claims without final outcomes; approximately 30% inconsistent serial-number formatting; 4,560 legacy Zoho claims labelled non-fraud. I treat older Zoho labels cautiously because some undecided claims were labelled non-fraud.

I remove duplicate submissions during preprocessing and exclude claims without final investigation outcomes from model training. Older Zoho records may contain unreliable labels because some undecided claims were labelled non-fraud.

My modeling and validation method is: Logistic Regression and Gradient Boosting predictions are combined; time-based validation evaluates later claims. This helps reduce the risk of using future information to evaluate past claims.

In June 2026 validation, 720 claims evaluated; 22 labelled fraud; 38 selected; 14 detected; 24 genuine claims incorrectly flagged; 64% detection; ₹284 estimated net saving per reviewed claim. The detection rate is 14 of 22 labelled fraud cases.

The validation sample is small, so detection rates and financial estimates are uncertain; the model performed better than evaluated simple comparisons, including reviewing the highest-value claims or prioritising all new partners.

My project overview also reports 2,252 test claims; 720 June claims; 22 fraud cases; 14 fraud cases detected; 7/7 format checks passed.

My repository privacy requirement is: Original or confidential claim datasets should not be committed to the public GitHub repository.

I evaluate this project using fraud detected and net money saved per claim reviewed rather than overall accuracy alone: with rare fraud labels and a constrained investigation desk, an all-non-fraud classifier could appear highly accurate while detecting no fraud. I keep policy-compliance findings separate from model predictions, and original input data separate from generated reports.

python run_pipeline.py

The pipeline loads and preprocesses data, removes duplicates and prepares features, analyses fraud patterns, trains models, validates them using time-based evaluation, generates claim-level risk predictions, and saves reports. Project components include run_pipeline.py, modules/preprocess.py, modules/train_model.py, modules/predict_claim.py, modules/validation.py, api.py, dashboard.py and app.py. Outputs include predictions.csv, scored_claims.csv, data_quality_report.csv, fraud_pattern_analysis.csv and validation_report.csv. My live dashboard is https://xugptpjrimtbus572dwu7m.streamlit.app/ and the repository is https://github.com/rskarthika2005-ai/Kestrel-Home-Warranty-Claim-Review-Variant-C-.

My featured projects extend the project work already described on this page, spanning receipt processing, warranty-claim review, support-ticket analytics, research assistance, traffic prediction, and educational applications. The profile describes project capabilities but gives no measured performance results, model scores, or dataset sizes.

I started the Vireo Audio support-ticket project in 2026-10, and it was last updated in 2026-10.

I describe the project as “AI-Assisted Support Analytics • Customer Experience • Business Intelligence.”

I describe the project as “Transforming customer support tickets into actionable insights using AI, analytics and interactive dashboards.”

I present Vireo Audio – Support Ticket Analysis as an AI-assisted project that turns approximately 18 months of customer support tickets into customer-experience and business insights.

I use Python, Pandas, Generative AI and Streamlit for the Vireo support analytics workflow.

  • My Vireo dashboard presents a Weekly Digest about what customers are complaining about, an Agent Leaderboard showing agent performance alongside repeat rate, breach rate and CSAT, and Money Finding for potential financial impact from support problems.

My stated goal is to reduce repeat customer contacts from 27.3% to 23.1%.

I use 23.1% as the benchmark achieved by the best large Voice Frontline team.

My live Vireo dashboard is available at https://fbh8ydtfxb7wecajwhehau.streamlit.app/, and the repository is at https://github.com/rskarthika2005-ai/Vireo-Audio-Support-Tickets-Set-A-.

My Tarang project is an AI-assisted receipt-processing application designed to extract and validate expense information from pharmaceutical distribution receipts.

My Tarang project extracts vendor, date, bill number, GSTIN, and amount from receipts.

My Tarang project validates receipt information and detects discrepancies.

My Tarang project identifies missing or inconsistent fields for review.

My Tarang project provides a Streamlit dashboard and FastAPI integration.

My Kestrel project cleans and preprocesses warranty claim records.

My Kestrel project identifies suspicious claim patterns using machine learning.

My Kestrel project generates fraud risk scores and review recommendations.

My Kestrel project provides prediction APIs and an interactive Streamlit dashboard.

My Kestrel project supports explainable, risk-based claim review.

My Vireo project analyzes and categorizes customer-support tickets.

My Vireo project identifies recurring complaints and customer sentiment.

My Vireo project generates weekly support-ticket summaries.

My Vireo project evaluates agent performance and operational metrics.

My Vireo project highlights opportunities to reduce repeat customer contacts.

My research assistant project includes information retrieval and analysis.

My research assistant project uses Retrieval-Augmented Generation (RAG).

My research assistant project includes LLM-based question answering.

My research assistant project includes context-aware response generation.

My research assistant project supports AI-assisted research workflows.

My traffic-prediction project analyzes and preprocesses traffic data.

My traffic-prediction project uses GRU-based temporal prediction.

My traffic-prediction project uses federated learning across distributed environments.

My study-notes project supports AI-assisted study note generation.

My study-notes project simplifies learning materials.

My study-notes project organizes important concepts.

My study-notes project aims to improve the learning and revision experience.

My student growth tracker identifies improvement areas.

My student growth tracker provides AI-assisted educational insights.

My listed AI and machine-learning skills include Machine Learning · Deep Learning · Computer Vision · OCR.

My listed Generative AI skills include Generative AI · Large Language Models · RAG.

My listed AI skills include AI Agents · Agentic AI · Federated Learning.

My listed technical foundations include Debugging · Testing · Problem-Solving.

I approach technical challenges by understanding requirements, breaking problems into smaller tasks, and developing practical solutions.

I strengthen my software development skills through Python, SQL, OOP, DSA, and hands-on application development.

I explore practical applications of machine learning, LLMs, RAG, AI agents, and document processing.

I focus on understanding errors, validating outputs, and improving application reliability.

I learn through documentation, technical courses, real-world projects, and experimentation.

My approach combines programming fundamentals, practical implementation, and continuous learning to build useful software and AI applications.

My engineering journey is presented as moving from Electronics to Software & AI.

My engineering journey includes Machine Learning • Deep Learning.

My engineering journey leads toward building practical AI applications.

I am continuously improving my skills in software engineering, machine learning, LLM applications, RAG workflows, AI agents, API integration, and reliable application development.

My Kestrel project is a machine-learning-based warranty fraud detection application designed to identify potentially fraudulent claims and prioritize cases for investigation.

My Vireo project is an AI-powered customer-support analytics application designed to analyze support tickets and generate actionable business insights.

My Agentic AI Research Assistant is a Python-based AI research assistant designed to retrieve and analyze information and provide context-aware answers.

My traffic-prediction project is an AI-based traffic prediction system that uses Federated Learning and a GRU model to analyze and predict traffic patterns across distributed environments.

My Personalized AI Study Notes Generator is an AI-based application designed to generate personalized study notes to support learning and make study materials easier to understand.

My AI Student Growth Tracker is an AI-based application designed to track student progress and growth.

I describe my project workflow as “Understand the Problem → Identify Requirements → Analyze Data and Constraints → Choose Suitable Technologies → Design the Solution → Build the Application → Test and Debug → Evaluate the Results → Improve the Solution.”

My education entry lists Sathyabama Institute of Science and Technology and a Bachelor of Engineering in Electronics & Communication Engineering for 2022 – 2026.

My profile lists my CGPA as 7.91 / 10.

My education entry states First Class with Distinction.

I list the Oracle Agentic AI Foundations Associate certification with the year 2026.

I list Agentic AI Engineering with LangChain & LangGraph with the year 2026.

I list the Complete Python Course certification without a year.

My engineering journey is presented as a progression from Electronics & Communication Engineering through programming fundamentals, Python and SQL, OOP and DSA, machine learning and deep learning, generative AI and LLMs, RAG and AI agents, and building practical AI applications. My motto is “Learning. Building. Improving.”

My current learning topics include Python, DSA, SQL, GenAI, RAG, and AI Agents. I say I am continuing to improve in software engineering, machine learning, LLM applications, RAG workflows, AI agents, API integration, and reliable application development.

My GitHub profile presents my path from Electronics and Communication Engineering toward software and artificial intelligence. It complements the project details I keep on this page with a concise overview of my background, interests, working style, and technical skills.

My GitHub profile and repository describe me as a Software Engineer • AI Enthusiast • ECE Graduate.

My profile states that I am a 2026 B.E. Electronics and Communication Engineering graduate.

My profile lists my location as Chennai, India.

My stated professional interests are interested in software engineering, artificial intelligence, and Generative AI.

My profile describes my hands-on project experience as hands-on project experience developing Python applications, machine learning solutions, LLM-powered analytics, document processing, RAG workflows, and AI agents.

  • My profile describes my work interests as solving real-world problems; building practical applications; debugging code.

My profile describes learning new technologies through project-based implementation.

My stated goal is to grow as a Software and AI Engineer.

My application goal is contributing to reliable, useful, and user-focused applications.

  • My listed programming languages are Python · SQL.
  • My listed AI and machine-learning skills are Machine Learning · Computer Vision · OCR.
  • My listed Generative AI skills are LLMs · RAG · AI Agents.
  • My listed frameworks are LangChain · LangGraph · PyTorch · Scikit-learn.
  • My listed application-development skills are Streamlit · FastAPI · REST APIs.
  • My listed database is MySQL.
  • My listed development tools are Git · GitHub.
  • My listed technical foundations are OOP · DSA · Debugging · Testing.

My GitHub profile links to my LinkedIn at https://www.linkedin.com/in/karthika-dev-ai.

My profile lists my contact email as mailto:rskarthika08@gmail.com.

My GitHub profile is https://github.com/rskarthika2005-ai.

My profile describes my journey as Building my journey from Engineering → Software → Artificial Intelligence.

The repository started 2026-09 and was last updated 2026-10.

I organized my Tarang Pharma Distribution Expense Receipt Reader as a Python project with a Streamlit dashboard, an API endpoint, a pipeline, supporting modules, data files, and saved reports. The repository’s README covers setup, running the project, behaviour without an API key, and limitations; my memo and completed submission form accompany the predictions.

My project data pack includes 467 original receipt photos, never modified.

My pipeline inspects datasets and maps photos to claims, checks image orientation and quality, reads receipt fields, validates and compares them with claims, and applies policy, duplicate, and suspicious-content checks to produce approve-or-review decisions. The modules separate analysis, preprocessing, OCR, validation, GSTIN rereading, decisions, and evaluation. The dashboard presents claim metrics, filters, receipt previews, OCR fields and confidence scores, mismatches, decisions and reasons, reports, and downloads. The API accepts a photo and claim and returns extracted fields, a decision, and reasons.

My final predictions cover all 190 test claims.

I save OCR results and confidence scores, cached photo reads, claim decisions and reasons, OCR-to-claim and OCR-to-clerk differences, image-quality and receipt-mapping reports, a hand-check table, and evaluation and dataset-analysis reports. These saved outputs and predictions can be reviewed without rerunning the model. My original receipt images remain unchanged.

git clone PASTE-GITHUB-REPO-LINK-HERE
cd tarang-expense-ai
python -m venv venv
venv\Scripts\activate
pip install -r requirements.txt
python pipeline.py
streamlit run app.py

I add the API key to .env; the app still starts without it, but reading a new photo requires a paid vision-model call. My project configuration reads the key from .env, and .gitignore keeps secrets, the virtual environment, and caches out of Git.

In my evaluation, 10 bill numbers were misread through dropped or added digits, even with confidence between 0.9 and 1.0.

My GSTIN accuracy is below 95%; the five test claims with wrong GSTIN values are CLM-31140, CLM-31158, CLM-31233, CLM-31299, CLM-31478. All five are in review, but their files still hold the wrong values.

Other observed issues include a possible passenger name read as the vendor for CLM-30527 and a possible brand read instead of the dealer for CLM-30944. GSTIN repair needs three valid sightings of a vendor, so new vendors may not benefit. Instruction-like stamps were caught on CLM-30623 and CLM-31401; the stamp on CLM-30982 was not transcribed, though that claim is in review for other reasons. Missing-photo claims have correct blank fields and are all in review.

I hand-checked 30 claims. Receipt dates were checked against the representative’s entered date, not independently against the photos.

I recommend judging GSTIN and bill-number accuracy against the photo, not only the clerk's typing.

I recommend a controlled pilot of auto-approval only for claims under ₹2,000, and only when the bill amount matches the claim, the photo is clear, all required fields are present, confidence and validation checks pass, and no duplicate or suspicious-content flag is raised. Claims of ₹2,000 or more and all uncertain cases should remain with clerks. I do not describe the tool as 95% accurate overall: bill-number errors occurred even at high confidence, GSTIN accuracy is below 95%, and the hand-check sample was small. The tool flags suspicious claims; it does not decide disciplinary outcomes.

I asked Nilesh to arrange a weekly quality audit in which a clerk checks one in every 20 approved claims against the photo.

I requested a model budget of about ₹5,000 per month and an API key.

I also asked for review of CLM-30982 as a possible duplicate bill, and CLM-30623 and CLM-31401 for instruction-like stamps. The repository URL remains a placeholder, the API key and budget have no stated approval outcome, and no review outcomes are provided.

My contact email for the Tarang Pharma Distribution Expense Receipt Reader is rskarthika08@gmail.com.

I built the Tarang Pharma receipt-reader project to extract receipt data, review expense claims, evaluate the pipeline, and provide a user interface. It extends the project description already on my github profile page.

I used Python for the project.

I used Pandas for the project.

I used OpenAI%20API for the project.

I used FastAPI for the project.

I used Streamlit for the project.

I used Git%20%26%20GitHub for the project.

I Read vendor, bill date, bill number, GSTIN and amount from phone photos, with a confidence score for each field.

I Used short JSON-only prompts and treated all printed text as data, so instruction-like stamps on bills could not steer the model.

I Corrected orientation, resized photos to 2,000 pixels, and checked blur, brightness and contrast.

I Fixed look-alike GSTIN characters using format rules and check digits, and corrected taxi-fare amount reads.

I Applied the expense policy, duplicate checks and suspicious-GSTIN flags to choose approve or review.

I Measured field accuracy and all-five-field accuracy, counted cases helped and hurt by each change, and hand-checked 30 test claims.

I Cached reads, reread only failed GSTINs and subtracted model cost from the savings estimate.

I Built a Streamlit review screen and a FastAPI endpoint on the same pipeline.

I Split the code into config, modules, outputs and entry-point files so each part has one clear job.

I Wrote a memo with a clear recommendation, limitations and what is needed from the client.

My GitHub profile lists Python (8), HTML (1) across the listed repositories.

I have been on GitHub since 2025.

My Price-Forecast-Task project is described as: Built a Python-based price forecasting model using SARIMA, Prophet, and XGBoost, with model evaluation, business impact analysis, cost-saving insights, FastAPI deployment, and an interactive Streamlit dashboard.

My Price-Forecast-Task repository is on @rskarthika2005-ai's GitHub, but its README still contains PASTE-GITHUB-REPO-LINK-HERE instead of the repository URL.

My price dataset contains 249 monthly prices from Jan 2005 to Sep 2025, with no missing months and no duplicates.

My prices peak around 2011, 2014-15, 2020 and 2024 instead of following one straight trend.

My seasonal component is only about ±250 on prices ranging from 3,500 to 16,000.

My prices jumped and stayed between 11,000 and 16,000.

I converted dates, sorted by time and set the date as the index.

I checked missing months, duplicates, IQR outliers and rolling-mean anomalies.

I ran the ADF test on prices and on first differences.

I used ACF and PACF plots to keep model orders small.

I tested XGBoost with lag features, month and rolling mean, tuned with TimeSeriesSplit.

I retrained the best model on all the data, forecast 12 months ahead, and turned it into business recommendations.

My project structure includes price_forecast.ipynb, requirements.txt, README.md, a Streamlit app, a /predict endpoint, Django integration code, and a saved ARIMA (0,1,0) model.

I run the notebook with jupyter notebook price_forecast.ipynb and choose Restart and Run All.

My dashboard presents history, the 12-month forecast and confidence band, a monthly forecast table, model comparison, budget planner and monitoring check.

My API returns forecast JSON with the date, forecast, lower 95% and upper 95% for each month.

I recommend buying in phases instead of making one large purchase.

I recommend signing fixed or forward contracts for part of the volume.

I recommend adding a price-adjustment clause in customer contracts.

I recommend avoiding long fixed contracts at today's high price.

I recommend keeping inventory low and buying as needed.

I recommend negotiating flexible or index-linked supplier pricing.

I plan to add external factors such as weather, demand and input costs, and test them as features.

I plan to retrain monthly and alert if MAPE goes above 15%.

I will keep tuned XGBoost as the challenger and replace ARIMA only if it does better on recent data.

My validation rule is: Time series data must never be split randomly, because that lets the model see the future.

My outlier review found: Seven months were flagged as IQR outliers (Dec 2023, Apr-Jul 2024, Jul 2025).

My stationarity result was: The ADF test gave p = 0.4669 on the original prices and p = 0.0 after one difference, so the models use d = 1.

My challenger decision was: tuned XGBoost stays for monitoring.

My ARIMA test result was '| ARIMA (0,1,0) | 1160.33 | 1565.74 | 9.12% |'.

My tuned XGBoost result was: tuned XGBoost has train MAPE 3.64% against test MAPE 9.18%, a sign of mild overfitting.

My model comparison found: Prophet under-predicted because it missed the 2024 jump, and SARIMA's seasonal terms added noise because seasonality is weak.

My forecast was: Point forecast: about 15,750 for every month (the last known price).

My forecast interval was: 95% range: widens from 14,107 to 17,393 (Oct 2025) to 10,060 to 21,440 (Sep 2026).

My risk assessment was: The current level is far above the long-term average of about 7,900, so downside risk is real.

My contract and planning recommendation is: In both cases, cover about half the expected demand with contracts, use the upper band as the worst-case budget, and re-run the forecast every month.

My project deliverables include a 16-section notebook, a Streamlit dashboard, and a FastAPI endpoint.

My project tools were Python, Pandas, NumPy, Statsmodels, Prophet, XGBoost, Scikit-learn, Matplotlib, FastAPI, Streamlit, and Claude.

My dashboard and contact details are https://price-forecast-task-yl4dwyfy4ggws3jnlvajn9.streamlit.app/ and rskarthika08@gmail.com.

My Price-Forecast-Task repository was last updated 2026-11.

My rskarthika2005-ai repository was last updated 2026-10.

My Tarang-Pharma-Distribution-expense-receipts project is described as: Tarang Expense AI uses OCR and AI to extract receipt data, validate expense claims against company policies, detect discrepancies, and flag problematic receipts for review.

The Tarang Expense AI project is described as: Built with Python, Streamlit, and FastAPI, it streamlines expense verification and reporting.

My Tarang-Pharma-Distribution-expense-receipts repository was last updated 2026-10.

For my Tarang Pharma receipt reader, I keep paid AI use limited to reading receipt photos; the repair rules, policy checks, duplicate checks, decisions, and evaluation run locally in Python. This keeps per-claim costs small and makes the decision logic easy to inspect.

Python handles my pipeline and application development, with no separate language usage fee.

I use Pandas for data analysis and reports through local processing.

The GPT mini vision model (OpenAI API) reads vendor, bill date, bill number, GSTIN and amount from receipt photos; the paid API costs about $0.024 (₹2.10) per claim.

FastAPI provides my receipt-reading endpoint, and hosting may incur costs.

Streamlit provides my interactive dashboard, and hosting costs depend on deployment.

I use Claude for planning, coding, debugging and checking; its cost depends on the account and service used.

The exact GPT model name is set in source/config.py, and I still need to confirm it there.

The vision model is the only paid part of my receipt-reading workflow.

For each bill photo, the vision model returns the five receipt fields with a confidence score for each.

Before reading, I turn each photo upright and resize it to 2,000 pixels; I use a short prompt requesting JSON-only output to save tokens.

GSTIN repair, amount repair, suspicious-content flags, policy rules, duplicate checks, and approve-or-review decisions all run locally and need no API call.

I store the OpenAI API key in a project .env file read by source/config.py; I never put it in code or commit it to GitHub, and .env is in .gitignore.

Create `.env` in the project root with `OPENAI_API_KEY=your-key-here`; use the same variable name that `source/config.py` reads.

Without an API key, my dashboard still starts and shows all saved results; reading a new photo requires a valid key and credits, and fails politely with a clear message if they are unavailable.

From 9–16 October 2026, my receipt reader made 3,034 API requests, used 40,247,791 tokens, spent $11.27, and processed 473 claims.

At 2,400 claims per month, the estimated model cost is about ₹5,030.

The estimated staff time freed per month is about 102 hours, worth about ₹24,300.

My estimated net monthly benefit is about ₹19,300, and the estimated annual benefit is about ₹2.3 lakh.

These cost and benefit figures are estimates, not guaranteed cash savings; they assume the test approval rate continues and exclude some review-related time savings.

  • To reduce token use and cost, I save receipt reads to avoid repeat API cost, resize images to 2,000 pixels, use short JSON-only prompts, re-read only GSTINs that fail the check digit, and stop immediately when credits run out.

My Kestrel-Home-Warranty-Claim-Review-Variant-C- project is described as: Warranty claim fraud scoring for Kestrel Home: a score, risk level and plain-English reasons per claim, plus a review queue sized to the investigation desk's 40 claims a month.

My Kestrel-Home-Warranty-Claim-Review-Variant-C- repository was last updated 2026-10.

My Vireo-Audio-Support-Tickets-Set-A- project is described as: AI-assisted support ticket analytics for Vireo Audio, including weekly complaint trends, agent performance, business insights, and validation.

My Vireo-Audio-Support-Tickets-Set-A- repository was last updated 2026-10.

My Personalized-AI-Study-Notes-Generator repository was last updated 2026-09.

My AI-Student-Growth-Tracker repository was last updated 2026-09.

My AI-Chatbot-using-LangChain-Python repository is listed as Python and was last updated 2026-09.

My Agentic-AI-Research-Assistant repository is listed as Python and was last updated 2026-07.

My CareerPilot-AI-Agent repository is listed as Python and was last updated 2026-07.

My Decentralized-Traffic-Prediction-using-Federated-Learning-and-GRU-Model- project is described as: Developed an AI-based traffic prediction system using Federated Learning and GRU architecture to analyze and predict traffic patterns in distributed environments.

Work on my traffic-prediction project is described as: Performed software design, testing, debugging, documentation, and performance evaluation to improve system reliability and predictive efficiency.

My Decentralized-Traffic-Prediction-using-Federated-Learning-and-GRU-Model- repository is listed as HTML and was last updated 2026-07.

My Snake-Detection-and-Mobile-Alert-System-using-Python-and-LangChain repository was last updated 2026-07.

My Student-Management-System-Java-MySQL- repository was last updated 2026-05.

My HomeAssistant-MQTT-Karthika-42130220 project is described as: The project is an end-to-end IoT data pipeline demonstrating the integration of simulated sensor data (Temperature, Humidity, Soil Moisture) from a Python publisher to a central Mosquitto MQTT broker, for real-time visualization on a Home Assistant dashboard.

My HomeAssistant-MQTT-Karthika-42130220 repository is listed as Python and was last updated 2025-12.

My profile does not give further descriptions for several repositories, and it provides no performance metrics, model scores, deployment outcomes, or quantified cost savings.

My GitHub profile was last updated 2025-12.