Agentic AI applications for real-world issues

Inspiration Our inspiration is rooted in the challenges and opportunities unique to India. We observed critical gaps in sectors like agriculture, healthcare, and public services, where access to expert knowledge and efficient processes is often limited by geography and resources. The question we asked was: How can we democratize expertise and automate complex decision-making for millions?

The answer emerged with IBM's open-source Agentic AI stack. The Granite series models, pretrained on code and language, offered a robust foundation for understanding and generating complex, domain-specific content. The Agent Development Kit (ADK) provided the perfect framework to orchestrate multi-step, real-world workflows. We were inspired to build not just one solution, but a flexible, agentic platform—AakashGyan—that could be tailored to multiple India-centric problems, delivering actionable intelligence directly into the hands of those who need it most.

What It Does AakashGyan is a suite of autonomous AI agents built on a common core. Each agent tackles a specific, high-impact problem:

KrishiSahayak : A farmer can send a voice note in their local language describing a crop issue .The agent autonomously executes a workflow: it transcribes the audio, translates it to English, analyzes the symptoms using an agricultural knowledge base powered by a Granite model, considers local weather data fetched via an API, and returns a diagnosis, organic treatment plan, and government advisory in the farmer's native language via SMS.

ArogyaMitra : A user in a remote primary health center describes their symptoms. The agent engages in a structured dialogue to gather crucial information (location, intensity, duration), consults medical guidelines, and provides a preliminary triage recommendation—not a diagnosis, but guidance on whether to seek immediate emergency care, schedule a visit with a general physician, or try basic home care. It can also map the nearest appropriate healthcare facilities.

VidyutSarthi : This agent helps small business owners navigate government schemes and compliance. A user can ask, "What subsidies are available for installing solar panels in Ahmedabad?" The agent will break down the query, search through its curated database of official documents (scraped and indexed using IBM's data toolkit), extract eligibility criteria, application steps, and required documentation, and present a simple, actionable summary.

How We Built It We built AakashGyan with a modular, scalable architecture centered on the IBM Agent Development Kit (ADK).

Core Agent Framework (IBM ADK): The ADK is the brain of the operation. We defined specific Tools for each agent (e.g., fetch_weather_data, query_govt_schemes_db, analyze_crop_symptoms) and Orchestrators that chain these tools together into logical workflows based on the user's query.

Large Language Models (IBM Granite): We leveraged different Granite models for different tasks:

Granite-13B-Code: Excellent for the complex logical reasoning required to break down a user's problem and decide which tools to call and in what sequence (powering the orchestrator's decision-making).

Granite-8B-Language: Perfect for summarizing large documents (like government schemes), generating clear, concise responses in multiple languages, and performing knowledge-intensive tasks like symptom analysis based on our curated datasets.

Data Pipeline: We used IBM's data preprocessing toolkits to clean, structure, and prepare datasets from various Indian government portals (e.g., agricultural bulletins, healthcare guidelines, subsidy schemes). This data was then vectorized and stored in a ChromaDB vector database for efficient semantic search by the agents.

Integration Layer: The agents interact with the real world via APIs:

Twilio API for SMS and voice input/output.

Weather APIs (OpenWeatherMap) for real-time environmental context.

Custom-built scrapers (using BeautifulSoup/Scrapy) to keep the knowledge base updated.

User Interface: A simple multi-format interface: a lightweight Flask web app for demo purposes and a WhatsApp Business API connector for maximum accessibility in the Indian context.

Challenges We Faced Context Length & Hallucination: Initially, the agents would sometimes get lost in long documents or invent non-existent schemes. We combated this by implementing a rigorous Retrieval-Augmented Generation (RAG) pipeline with the vector database, ensuring the model only uses curated, relevant information from our knowledge base to ground its responses.

Multi-lingual Complexity: Handling Hinglish and other local dialects was a challenge. We integrated a pre-processing step using open-source translation APIs before analysis and then translated the results back, ensuring accuracy wasn't lost in translation.

Orchestrating Complex Workflows: Designing the ADK orchestrator to handle non-linear, conditional workflows (e.g., "if symptom X is present, ask follow-up question Y") required careful state management and error handling to ensure a smooth user experience.

Latency for Real-Time Use: Chaining multiple LLM calls and API requests added latency. We optimized by running some models in parallel where possible and implementing efficient caching strategies for frequently accessed data.

What's Next for AakashGyan Agent Specialization: Train fine-tuned versions of Granite models on specific Indian datasets (agriculture, legal, healthcare) for even greater accuracy.

Voice-First Interface: Deep integration with WhatsApp and simple IVR systems to make it truly accessible to the least tech-literate users.

Multi-Agent Collaboration: Deploy agents that can collaborate; e.g., the healthcare agent referring a patient to a government scheme agent to find financial support.

Pilot Deployment: Partner with NGOs and government bodies in one district for a real-world pilot program to validate impact and refine the system.

Built With

• adk
• agent
• cloud
• code
• development
• engine
• flask-knowledge-management:-chromadb-(vector-database)
• for
• git
• github
• google-translate-api-tools-&-deployment:-docker
• granite-8b-language)-data-processing:-ibm-data-preprocessing-&-preparation-toolkits
• hugging-face-transformers-library-infrastructure:-local-llm-inference-(for-demo)
• ibm
• kit
• numpy-backend:-python
• openweathermap-api
• pandas
• scalable
• sqlite-apis-&-integrations:-twilio-api-(sms/voice)
• whatsapp-business-api