AI applications are moving beyond simple question-and-answer chatbots.

Modern AI systems can use tools, access external data, retrieve information from knowledge bases, and perform specific tasks based on a user's request.

As part of my hands-on AI learning journey, I built an Agentic Insurance Operations Assistant that demonstrates this approach in a real-world insurance use case.

The application allows users to ask questions about insurance claims, high-priority claims, insurance policies, and claim analytics.

Instead of hardcoding responses, the AI agent determines which tool should be used and retrieves the required information from the appropriate data source.

What Problem Does It Solve?

Insurance operations involve working with different types of information:

• Claim details

• Claim status

• Claim priority

• Insurance policies

• Claim processing rules

• Operational statistics

A traditional application might require users to navigate multiple screens or APIs to retrieve this information.

The goal of this project was to create a single AI-powered interface where an insurance operations user can simply ask a question.

For example:

"What is the status of claim 1001?"

or:

"Show me all high-priority claims."

or:

"What happens when a claim is rejected?"

The system determines how to handle the request and retrieves the relevant information.

Project Architecture

The overall architecture is:

                    User
                      |
                      v
              React Frontend
                      |
                      | HTTP
                      v
              FastAPI Backend
                      |
                      v
                LangChain Agent
                 /           \
                /             \
               v               v
        Ollama / Llama 3.2    MCP Server
                               |
                 +-------------+-------------+
                 |             |             |
                 v             v             v
          Claim Lookup    High Priority   Analytics
                 |
                 v
             PostgreSQL

                       MCP
                        |
                        v
                 Policy Search
                        |
                        v
                  RAG + FAISS

The system is containerized using Docker, while Ollama provides local LLM inference.

Building an Agentic AI Insurance Operations Assistant with LangChain, MCP, Ollama, RAG, and FastAPI

Introduction

AI applications are moving beyond simple question-and-answer chatbots.

Modern AI systems can use tools, access external data, retrieve information from knowledge bases, and perform specific tasks based on a user's request.

As part of my hands-on AI learning journey, I built an Agentic Insurance Operations Assistant that demonstrates this approach in a real-world insurance use case.

The application allows users to ask questions about insurance claims, high-priority claims, insurance policies, and claim analytics.

Instead of hardcoding responses, the AI agent determines which tool should be used and retrieves the required information from the appropriate data source.

What Problem Does It Solve?

Insurance operations involve working with different types of information:

• Claim details

• Claim status

• Claim priority

• Insurance policies

• Claim processing rules

• Operational statistics

A traditional application might require users to navigate multiple screens or APIs to retrieve this information.

The goal of this project was to create a single AI-powered interface where an insurance operations user can simply ask a question.

For example:

"What is the status of claim 1001?"

or:

"Show me all high-priority claims."

or:

"What happens when a claim is rejected?"

The system determines how to handle the request and retrieves the relevant information.

Project Architecture

The overall architecture is:

                    User
                      |
                      v
              React Frontend
                      |
                      | HTTP
                      v
              FastAPI Backend
                      |
                      v
                LangChain Agent
                 /           \
                /             \
               v               v
        Ollama / Llama 3.2    MCP Server
                               |
                 +-------------+-------------+
                 |             |             |
                 v             v             v
          Claim Lookup    High Priority   Analytics
                 |
                 v
             PostgreSQL

                       MCP
                        |
                        v
                 Policy Search
                        |
                        v
                  RAG + FAISS

The system is containerized using Docker, while Ollama provides local LLM inference.

Technology Stack

Backend

• Python

• FastAPI

• SQLAlchemy

• PostgreSQL

AI

• LangChain

• Ollama

• Llama 3.2

• Agent-based tool calling

Agent Tool Layer

• Model Context Protocol (MCP)

• Four MCP tools

RAG

• Sentence Transformers

• FAISS

• Insurance policy documents

Frontend

• React

• Vite

Infrastructure

• Docker

• Docker Desktop

How the AI Agent Works

The most important part of this project is the AI agent.

The user does not need to tell the application which tool to use.

Instead, the agent receives the question and determines which available tool is relevant.

For example:

Question 1

"What is the status of claim 1001?"

The agent identifies this as a claim lookup request and uses the claim lookup tool.

The tool retrieves the claim from PostgreSQL and returns information such as:

Claim ID: 1001
Claim Type: Auto Accident
Status: PENDING
Priority: HIGH
Estimated Damage: $45,000

The agent then converts the tool result into a natural-language response.

MCP Tool Architecture

This project uses Model Context Protocol (MCP) to provide the agent with structured tools.

I implemented four tools.

1. Claim Lookup

This tool retrieves information about a specific claim.

Example:

"What is the status of claim 1001?"

The tool queries the PostgreSQL claims database.

2. High-Priority Claims

This tool retrieves claims marked as high priority.

Example:

"Show me all high-priority claims."

The system returned claims such as:

Claim 1001
Type: Auto Accident
Status: PENDING
Priority: HIGH
Estimated Damage: $45,000

Claim 1003
Type: Theft
Status: PENDING
Priority: HIGH
Estimated Damage: $32,000

3. Insurance Policy Search

The third tool handles insurance policy questions.

For example:

"What happens when a claim is rejected?"

Instead of asking the LLM to generate an answer from memory, the agent uses the policy-search tool.

The relevant policy information is retrieved through the project's RAG pipeline and provided to the agent.

This helps keep policy-related responses grounded in the available policy information.

4. Claim Analytics

The fourth tool provides claim-related analytics.

For example:

"Give me claim statistics and analytics."

The agent uses the analytics tool to retrieve the available statistics rather than generating numbers itself.

Retrieval-Augmented Generation (RAG)

The project also includes a policy knowledge component using Retrieval-Augmented Generation.

The basic workflow is:

Insurance Policy Documents
          |
          v
       Chunking
          |
          v
     Embeddings
          |
          v
     FAISS Vector Store
          |
          v
       User Query
          |
          v
   Similarity Search
          |
          v
 Relevant Policy Context
          |
          v
       AI Agent
          |
          v
       Response

This allows the system to search the insurance policy knowledge base when a user asks a policy-related question.

The purpose is to reduce the need for the language model to rely only on its pretrained knowledge.

PostgreSQL Claim Database

Claim information is stored in PostgreSQL.

The project currently contains sample claims that include information such as:

• Claim ID

• Claim type

• Status

• Priority

• Estimated damage

For example:

Claim ID: 1001
Claim Type: Auto Accident
Status: PENDING
Priority: HIGH
Estimated Damage: $45,000

The MCP claim tools interact with this database to retrieve the required information.

React Frontend

I built a React frontend to provide a simple interface for interacting with the AI agent.

The interface allows users to:

• Enter natural-language questions

• Submit questions to the AI agent

• View the generated response

• Use predefined example questions

Example quick actions include:

• Claim 1001 Status

• High-Priority Claims

• Rejected Claims Policy

• Claim Analytics

The frontend communicates with the FastAPI backend through HTTP requests.

FastAPI Backend

FastAPI acts as the backend API layer.

The main AI endpoint is:

POST /agent

The frontend sends a question to this endpoint.

The backend passes the question to the AI agent, which determines whether one of the available MCP tools should be used.

The resulting answer is then returned to the React application.

Ollama and Local LLM Inference

One of the interesting decisions in this project was using Ollama with Llama 3.2 for local LLM inference.

Instead of depending on a hosted LLM API for the agent workflow, the project uses a locally running model.

This provided hands-on experience with:

• Local LLM inference

• Agent tool calling

• Connecting a containerized application to a host-based LLM

• Building an AI application without requiring every inference request to go through a cloud API

Docker Containerization

The FastAPI application was containerized using Docker.

The Dockerized architecture communicates with:

• PostgreSQL

• Ollama running locally

• MCP tools

• React frontend

One challenge was networking between the Docker container and services running on the host machine.

The application was configured to use:

host.docker.internal

for communication with host-based services.

This was an important practical lesson because networking behavior inside a Docker container is different from running the application directly on Windows.

Testing the Application

I tested the application using four main scenarios.

Test 1 — Claim Lookup

Question:

"What is the status of claim 1001?"

Result:

The status of claim 1001 is PENDING.

Test 2 — High-Priority Claims

Question:

"Show me all high-priority claims."

The agent retrieved the high-priority claims through the MCP tool.

Test 3 — Policy Question

Question:

"What happens when a claim is rejected?"

The agent used the policy-search/RAG workflow to retrieve relevant policy information.

Test 4 — Analytics

Question:

"Give me claim statistics and analytics."

The agent used the analytics tool and returned the available claim statistics.

All four workflows were successfully tested through the React frontend.

What I Learned

This project helped me understand several concepts beyond simply calling an LLM API.

1. Agents need tools

An LLM by itself does not automatically know the current state of an application's database.

Giving the agent structured tools allows it to interact with external systems.

2. MCP provides a structured tool layer

MCP helped me separate the AI reasoning layer from the operations that actually retrieve information.

3. RAG is useful for domain-specific knowledge

For insurance policy questions, retrieving relevant policy information before generating the response provides a more controlled approach than relying only on the model's general knowledge.

4. Local LLMs are practical for development

Ollama made it possible to experiment with an LLM locally and understand the architecture without making every development request dependent on a hosted model.

5. Docker introduces real deployment considerations

Containerizing the backend exposed practical issues around networking, dependencies, database connectivity, and communication between containerized and host-based services.

Challenges I Encountered

One of the biggest challenges was connecting all the components together.

The final system involved:

React
  ↓
FastAPI
  ↓
LangChain Agent
  ↓
Ollama
  ↓
MCP
  ↓
PostgreSQL / RAG

I encountered issues with:

• Docker networking

• PostgreSQL connectivity from the container

• CORS between React and FastAPI

• Local Ollama connectivity

• Python dependencies inside Docker

• CPU-only PyTorch dependencies for reducing Docker image size

Solving these issues helped me understand how the individual technologies work together in a real application.

Project Outcome

The final application provides a single AI interface for several insurance operations.

It can:

✅ Retrieve individual claim information

✅ Identify high-priority claims

✅ Search insurance policy information using RAG

✅ Provide claim analytics

✅ Use MCP tools through an AI agent

✅ Run LLM inference locally with Ollama

✅ Communicate through a React frontend

✅ Run the backend inside Docker

Future Improvements

There are several areas I would like to explore next:

• Improve agent response latency

• Add authentication and authorization

• Add more insurance operations tools

• Add richer analytics dashboards

• Improve RAG evaluation

• Add automated testing

• Add monitoring and logging

• Deploy the application to Azure

• Add production-grade model and tool evaluation

Conclusion

Building this project gave me hands-on experience moving from traditional AI applications toward agentic AI systems.

The main lesson was that an effective AI application is not just about the language model.

The surrounding architecture matters:

LLM + tools + data + retrieval + APIs + database + infrastructure

Combining these components allowed me to build an insurance operations assistant that can interact with real application data and domain-specific knowledge.

This project was a valuable step in my journey toward building practical AI applications with Python and modern AI technologies.

GitHub

The complete project source code is available here:

https://github.com/shiva-priya123/agentic-insurance-assistant\_4solutions-

Technologies Used

Python FastAPI React LangChain MCP Ollama Llama 3.2 RAG FAISS PostgreSQL SQLAlchemy Docker Vite

#AI #AgenticAI #GenerativeAI #Python #FastAPI #LangChain #MCP #RAG #Ollama #PostgreSQL #Docker #React #ArtificialIntelligence

Technology Stack

Backend

• Python

• FastAPI

• SQLAlchemy

• PostgreSQL

AI

• LangChain

• Ollama

• Llama 3.2

• Agent-based tool calling

Agent Tool Layer

• Model Context Protocol (MCP)

• Four MCP tools

RAG

• Sentence Transformers

• FAISS

• Insurance policy documents

Frontend

• React

• Vite

Infrastructure

• Docker

• Docker Desktop

How the AI Agent Works

The most important part of this project is the AI agent.

The user does not need to tell the application which tool to use.

Instead, the agent receives the question and determines which available tool is relevant.

For example:

Question 1

"What is the status of claim 1001?"

The agent identifies this as a claim lookup request and uses the claim lookup tool.

The tool retrieves the claim from PostgreSQL and returns information such as:

Claim ID: 1001
Claim Type: Auto Accident
Status: PENDING
Priority: HIGH
Estimated Damage: $45,000

The agent then converts the tool result into a natural-language response.

MCP Tool Architecture

This project uses Model Context Protocol (MCP) to provide the agent with structured tools.

I implemented four tools.

1. Claim Lookup

This tool retrieves information about a specific claim.

Example:

"What is the status of claim 1001?"

The tool queries the PostgreSQL claims database.

2. High-Priority Claims

This tool retrieves claims marked as high priority.

Example:

"Show me all high-priority claims."

The system returned claims such as:

Claim 1001
Type: Auto Accident
Status: PENDING
Priority: HIGH
Estimated Damage: $45,000

Claim 1003
Type: Theft
Status: PENDING
Priority: HIGH
Estimated Damage: $32,000

3. Insurance Policy Search

The third tool handles insurance policy questions.

For example:

"What happens when a claim is rejected?"

Instead of asking the LLM to generate an answer from memory, the agent uses the policy-search tool.

The relevant policy information is retrieved through the project's RAG pipeline and provided to the agent.

This helps keep policy-related responses grounded in the available policy information.

4. Claim Analytics

The fourth tool provides claim-related analytics.

For example:

"Give me claim statistics and analytics."

The agent uses the analytics tool to retrieve the available statistics rather than generating numbers itself.

Retrieval-Augmented Generation (RAG)

The project also includes a policy knowledge component using Retrieval-Augmented Generation.

The basic workflow is:

Insurance Policy Documents
          |
          v
       Chunking
          |
          v
     Embeddings
          |
          v
     FAISS Vector Store
          |
          v
       User Query
          |
          v
   Similarity Search
          |
          v
 Relevant Policy Context
          |
          v
       AI Agent
          |
          v
       Response

This allows the system to search the insurance policy knowledge base when a user asks a policy-related question.

The purpose is to reduce the need for the language model to rely only on its pretrained knowledge.

PostgreSQL Claim Database

Claim information is stored in PostgreSQL.

The project currently contains sample claims that include information such as:

• Claim ID

• Claim type

• Status

• Priority

• Estimated damage

For example:

Claim ID: 1001
Claim Type: Auto Accident
Status: PENDING
Priority: HIGH
Estimated Damage: $45,000

The MCP claim tools interact with this database to retrieve the required information.

React Frontend

I built a React frontend to provide a simple interface for interacting with the AI agent.

The interface allows users to:

• Enter natural-language questions

• Submit questions to the AI agent

• View the generated response

• Use predefined example questions

Example quick actions include:

• Claim 1001 Status

• High-Priority Claims

• Rejected Claims Policy

• Claim Analytics

The frontend communicates with the FastAPI backend through HTTP requests.

FastAPI Backend

FastAPI acts as the backend API layer.

The main AI endpoint is:

POST /agent

The frontend sends a question to this endpoint.

The backend passes the question to the AI agent, which determines whether one of the available MCP tools should be used.

The resulting answer is then returned to the React application.

Ollama and Local LLM Inference

One of the interesting decisions in this project was using Ollama with Llama 3.2 for local LLM inference.

Instead of depending on a hosted LLM API for the agent workflow, the project uses a locally running model.

This provided hands-on experience with:

• Local LLM inference

• Agent tool calling

• Connecting a containerized application to a host-based LLM

• Building an AI application without requiring every inference request to go through a cloud API

Docker Containerization

The FastAPI application was containerized using Docker.

The Dockerized architecture communicates with:

• PostgreSQL

• Ollama running locally

• MCP tools

• React frontend

One challenge was networking between the Docker container and services running on the host machine.

The application was configured to use:

host.docker.internal

for communication with host-based services.

This was an important practical lesson because networking behavior inside a Docker container is different from running the application directly on Windows.

Testing the Application

I tested the application using four main scenarios.

Test 1 — Claim Lookup

Question:

"What is the status of claim 1001?"

Result:

The status of claim 1001 is PENDING.

Test 2 — High-Priority Claims

Question:

"Show me all high-priority claims."

The agent retrieved the high-priority claims through the MCP tool.

Test 3 — Policy Question

Question:

"What happens when a claim is rejected?"

The agent used the policy-search/RAG workflow to retrieve relevant policy information.

Test 4 — Analytics

Question:

"Give me claim statistics and analytics."

The agent used the analytics tool and returned the available claim statistics.

All four workflows were successfully tested through the React frontend.

What I Learned

This project helped me understand several concepts beyond simply calling an LLM API.

1. Agents need tools

An LLM by itself does not automatically know the current state of an application's database.

Giving the agent structured tools allows it to interact with external systems.

2. MCP provides a structured tool layer

MCP helped me separate the AI reasoning layer from the operations that actually retrieve information.

3. RAG is useful for domain-specific knowledge

For insurance policy questions, retrieving relevant policy information before generating the response provides a more controlled approach than relying only on the model's general knowledge.

4. Local LLMs are practical for development

Ollama made it possible to experiment with an LLM locally and understand the architecture without making every development request dependent on a hosted model.

5. Docker introduces real deployment considerations

Containerizing the backend exposed practical issues around networking, dependencies, database connectivity, and communication between containerized and host-based services.

Challenges I Encountered

One of the biggest challenges was connecting all the components together.

The final system involved:

React
  ↓
FastAPI
  ↓
LangChain Agent
  ↓
Ollama
  ↓
MCP
  ↓
PostgreSQL / RAG

I encountered issues with:

• Docker networking

• PostgreSQL connectivity from the container

• CORS between React and FastAPI

• Local Ollama connectivity

• Python dependencies inside Docker

• CPU-only PyTorch dependencies for reducing Docker image size

Solving these issues helped me understand how the individual technologies work together in a real application.

Project Outcome

The final application provides a single AI interface for several insurance operations.

It can:

✅ Retrieve individual claim information

✅ Identify high-priority claims

✅ Search insurance policy information using RAG

✅ Provide claim analytics

✅ Use MCP tools through an AI agent

✅ Run LLM inference locally with Ollama

✅ Communicate through a React frontend

✅ Run the backend inside Docker

Future Improvements

There are several areas I would like to explore next:

• Improve agent response latency

• Add authentication and authorization

• Add more insurance operations tools

• Add richer analytics dashboards

• Improve RAG evaluation

• Add automated testing

• Add monitoring and logging

• Deploy the application to Azure

• Add production-grade model and tool evaluation

Conclusion

Building this project gave me hands-on experience moving from traditional AI applications toward agentic AI systems.

The main lesson was that an effective AI application is not just about the language model.

The surrounding architecture matters:

LLM + tools + data + retrieval + APIs + database + infrastructure

Combining these components allowed me to build an insurance operations assistant that can interact with real application data and domain-specific knowledge.

This project was a valuable step in my journey toward building practical AI applications with Python and modern AI technologies.

GitHub

The complete project source code is available here:

https://github.com/shiva-priya123/agentic-insurance-assistant\_4solutions-

Technologies Used

Python FastAPI React LangChain MCP Ollama Llama 3.2 RAG FAISS PostgreSQL SQLAlchemy Docker Vite

#AI #AgenticAI #GenerativeAI #Python #FastAPI #LangChain #MCP #RAG #Ollama #PostgreSQL #Docker #React #ArtificialIntelligence