Case Study: AI-Assisted Report Generation with LangChain, FastAPI, and Anthropic Claude

Modern financial organizations process massive volumes of data — transactions, performance metrics, customer insights, risk indicators — yet much of it remains locked away in databases and static dashboards. Business analysts still spend hours writing SQL queries, exporting data to spreadsheets, and formatting reports manually.

At INSART, we imagined a more intelligent workflow:

What if a user could simply type “Show me sales by region for Q4 2024” — and an AI system would generate a complete, interactive report — including SQL queries, charts, and written insights — in seconds?

This is the story of how INSART would design and build that system: a hypothetical AI-Assisted Report Generation Platform, powered by LangChain, FastAPI, and Anthropic Claude, with Model Context Protocol (MCP) for secure data access and Plotly visualizations for interactive charts.

The Vision: Transforming Data Into Instant Narrative

The goal was not just to automate reports — it was to create a conversation with data.

Instead of forcing users to learn SQL or BI tools, the platform would interpret natural language, query the underlying database, visualize results, and write a clear, human-readable summary.

We envisioned the following experience:

1. A financial analyst types a question like,

   “Compare quarterly revenue growth across all EMEA regions.”

2. The AI parses this request, automatically generating SQL queries to extract the necessary data.

3. It retrieves results from a PostgreSQL database, builds a bar chart using Plotly, and generates a narrative analysis:

   “Revenue in EMEA increased by 12% quarter-over-quarter, led by Germany and the UK.”

4. The output appears as an interactive report — combining data tables, charts, SQL snippets, and executive insights.

This architecture — captured in the uploaded diagram — shows a modular, explainable, and secure design where each component serves a specific role in the data-to-report journey.

Architectural Overview

At the heart of the solution is an orchestrated AI pipeline that connects language understanding, data access, and visualization. The core flow includes:

• User Interface Layer (Query input + report display)

• FastAPI Backend (request validation and orchestration)

• LangChain Engine (manages workflow and LLM interaction)

• Anthropic Claude (reasoning, SQL generation, and analysis)

• MCP Server (secure database access via predefined tools)

• Database (PostgreSQL or SQL Server)

• Visualization Layer (Plotly/Matplotlib)

• Report Generator (final HTML/PDF output)

The architecture is designed to be modular and auditable — each stage logs its process, ensuring transparency in AI decision-making.

FastAPI: The Backbone of the Platform

The journey begins when a user sends a query through a web or chat interface. The FastAPI server receives the HTTP request, validates it, and prepares it for the orchestration layer.

Example FastAPI endpoint:

from fastapi import FastAPI, Request
from pydantic import BaseModel
from langchain.orchestrator import run_query_pipeline

app = FastAPI()

class QueryRequest(BaseModel):
    query: str

@app.post("/generate-report")
async def generate_report(request: QueryRequest):
    result = await run_query_pipeline(request.query)
    return {"report": result}

FastAPI was chosen for three reasons:

1. It’s asynchronous and lightweight — perfect for low-latency AI requests.

2. It supports OpenAPI documentation automatically.

3. It easily integrates with LangChain and external APIs.

FastAPI also handles user authentication, rate limiting, and caching — ensuring scalability and reliability under enterprise workloads.

LangChain: The Orchestration Layer

Once the request reaches the orchestration layer, LangChain takes over.

LangChain coordinates the reasoning flow between the LLM (Claude), the database tools (MCP), and the visualization components.

Conceptually, it performs these steps:

1. Passes the user’s query to Claude with schema context.

2. Interprets the response to identify which MCP tools to invoke.

3. Executes database queries through the MCP interface.

4. Collects results, validates structure, and triggers visualization generation.

5. Sends the outputs back to FastAPI for final packaging.

A simplified orchestration snippet:

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from anthropic import Anthropic

anthropic = Anthropic(api_key="YOUR_API_KEY")

prompt = PromptTemplate(
    input_variables=["user_query", "db_schema"],
    template="Generate a SQL query based on schema {db_schema} for: {user_query}"
)

chain = LLMChain(llm=anthropic, prompt=prompt)

def generate_sql(user_query, db_schema):
    return chain.run(user_query=user_query, db_schema=db_schema)

This orchestrator ensures that each step of the AI process — query understanding, SQL creation, and visualization — happens in a controlled, observable way.

Anthropic Claude: The Brain of the System

The Claude model plays a dual role: reasoning and communication.

It interprets natural language, translates it into structured queries, and later converts query results into readable narratives.

Example Claude prompt for SQL generation:

prompt = f"""
You are an expert financial analyst.
Given the database schema: {schema}
Write an SQL query that answers the following:
'{user_query}'
Only output valid SQL, without commentary.
"""
response = anthropic.completions.create(
    model="claude-3-opus",
    prompt=prompt,
    max_tokens=400
)
sql_query = response.completion.strip()

Claude doesn’t just generate queries blindly — it reasons about the data context and user intent.

For example, if the user asks, “Show average revenue per region in 2024”, Claude will infer that “region” refers to a table in the schema, join it with sales data, and aggregate by average revenue.

Later, the same model analyzes query results and crafts narrative insights:

narrative_prompt = f"""
Based on this data:
{results_json}
Write an executive summary with insights and trends.
"""
narrative = anthropic.completions.create(
    model="claude-3-opus",
    prompt=narrative_prompt,
    max_tokens=500
)

The result is a human-readable report — the kind an analyst might spend hours writing manually.

MCP Server: Secure Data Access Through Tools

Direct database access from an LLM would be a security nightmare.

That’s why INSART would introduce Model Context Protocol (MCP) — an intermediary layer that exposes safe, auditable tools to the AI model.

Available MCP tools:

• get_tables(): List available tables

• get_schema(): Retrieve table schemas

• execute_query(): Run a validated SQL query

• query_table(): Fetch limited data samples

Example MCP implementation:

class MCPToolset:
    def __init__(self, db):
        self.db = db

    def get_schema(self, table_name):
        query = f"SELECT column_name, data_type FROM information_schema.columns WHERE table_name = '{table_name}'"
        return self.db.execute(query)

    def execute_query(self, sql):
        if "DELETE" in sql or "UPDATE" in sql:
            raise Exception("Unsafe operation detected.")
        return self.db.query(sql)

This protocol ensures that Claude cannot perform destructive operations or access unauthorized data.

Every query is logged, validated, and sandboxed.

Visualization and Report Generation

Once the data is retrieved, the platform uses Matplotlib or Plotly to generate visuals.

Claude decides which visualization type best suits the data — e.g., a bar chart for category comparisons, a line chart for trends.

Example visualization pipeline:

import plotly.express as px
import pandas as pd

def generate_chart(data, chart_type="bar"):
    df = pd.DataFrame(data)
    if chart_type == "bar":
        fig = px.bar(df, x="region", y="sales", color="region", title="Sales by Region")
    elif chart_type == "line":
        fig = px.line(df, x="date", y="revenue", title="Revenue Over Time")
    return fig.to_html()

Finally, FastAPI compiles:

• The SQL query used

• Retrieved results

• Visuals

• AI-generated narrative

and returns it as a single interactive HTML report.

Security and Deployment Considerations

Because this platform deals with enterprise financial data, INSART would apply strict governance practices:

1. Read-only database credentials for MCP access

2. Query logging and rate limiting in FastAPI

3. Data masking for sensitive fields (PII, account IDs)

4. Encrypted API communication (TLS 1.3)

5. Containerized deployment using Docker + Kubernetes

6. Audit trails for every AI-generated query and decision

The entire infrastructure would run in a private cloud environment with role-based access control and SSO for enterprise users.

End-to-End Flow Summary

Here’s the narrative version of the process captured in your architecture diagram:

1. The user types a natural language query.

2. FastAPI validates it and routes it to LangChain.

3. LangChain sends schema information and user intent to Claude.

4. Claude generates a SQL query and calls MCP’s execute_query() method.

5. MCP executes the query securely on PostgreSQL and returns results.

6. Claude analyzes results, decides visualization type, and generates narrative.

7. The visualization component renders charts using Plotly.

8. FastAPI compiles all elements into a report (HTML, PDF, or CSV).

9. The report is returned to the user — complete with data, charts, and insights.

It’s a seamless pipeline that transforms questions into stories.

Business Value and Outcomes

Such a system would deliver measurable benefits:

• Time savings: Analysts save 70–80% of manual effort in report generation.

• Accessibility: Non-technical users gain direct access to complex data insights.

• Accuracy: SQL generated dynamically reduces human error and improves consistency.

• Governance: Every query is tracked, validated, and explainable.

• Scalability: The modular design allows for new data sources or models to be added effortlessly.

From a business standpoint, this platform converts static data analysis into a continuous, conversational intelligence layer across the organization.

The Tech Stack at a Glance

This combination balances innovation with enterprise reliability — every component is open, explainable, and extensible.

Conclusion: From Static Reports to Intelligent Conversations

The AI-Assisted Report Generation Platform is more than a proof of concept — it’s a glimpse into how INSART envisions the future of fintech analytics.

Instead of relying on pre-built dashboards, organizations can interact with their data as if speaking to an analyst. Reports are no longer static documents — they’re dynamic, intelligent responses built in real time, tailored to each question.

By blending FastAPI, LangChain, and Claude with secure data protocols, INSART demonstrates how natural language, structured data, and AI reasoning can coexist in a controlled, auditable enterprise environment.

This is not just automation — it’s augmentation.

And it represents the next step in the evolution of financial intelligence systems.