NarmathaVaiyapuri

Day 3 – Building an End-to-End AI Pipeline

2026-04-15T00:00:00-03:00

Introduction

In real-world AI systems, models alone are not enough. They need memory, structured outputs, and backend logic to work effectively.

To understand this, I built a simple end-to-end AI pipeline using a local model (llama.cpp) and MongoDB.

In this session, I focused on:

Running a local AI model
Structuring AI responses
Storing and retrieving data
Building a stateful AI system

1. Understanding the AI Pipeline

Flow

User → FastAPI → AI (llama.cpp) → Decision → MongoDB → Response

This pipeline shows how AI systems process input, use memory, and return meaningful responses.

2. Running a Local AI Model

I used llama.cpp with a GGUF model to run the AI locally.

Temperature → controls creativity
Top-p → controls randomness
Max tokens → controls response length

This allows better control, privacy, and offline capability.

3. Structuring AI Output

TOP:
Response for user

BOTTOM_JSON:
{
  "action": "store" | "retrieve" | "none",
  "data": "..."
}

This helps the system understand and act on AI responses.

4. MongoDB as a Memory System

{
  "text": "User likes AI",
  "date": "2026-04-15"
}

5. Building Stateful AI

Store user inputs
Retrieve memory
Use it in responses

6. AI Decision Making

store → save data
retrieve → fetch data
none → normal response

7. Pipeline Execution Logic

Receive user input through FastAPI
Retrieve memory from MongoDB
Send the prompt to the AI model
Generate a structured response
Parse the JSON output
Execute the required action
Return the final response

Final Thoughts

This project helped me understand how AI models, backend systems, and databases work together to build real-world applications.

By combining llama.cpp, MongoDB, and structured outputs, I built a simple system that can respond, remember, and take actions.

Day 2 – Building APIs with FastAPI

2026-04-14T00:00:00-03:00

Introduction

In Generative AI systems, models do not work in isolation. They rely on APIs to receive input, process data, and return responses.

To understand how backend systems work in AI applications, I built my first API using FastAPI.

In this session, I focused on:

Creating API endpoints
Handling data using GET and POST requests
Validating input using Pydantic
Testing APIs using Swagger UI

These concepts form the foundation of backend development for AI systems.

1. Setting Up FastAPI

Installation

To begin, I installed the required packages:

Command

pip install fastapi uvicorn

FastAPI → framework to build APIs
Uvicorn → ASGI server to run the application

Role in GenAI

APIs act as the bridge between users and AI models. They handle incoming requests and send back model responses.

2. Creating the FastAPI Application

Basic Setup

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello, GenAI World!"}

Explanation

FastAPI() initializes the application
@app.get("/") defines a GET endpoint
The function returns a JSON response

Role in GenAI

This is similar to how AI services expose endpoints to interact with models.

3. GET Endpoint – Retrieving Data

Example

@app.get("/items")
def get_items():
    return {
        "items": [
            {"id": 1, "name": "AI Agent"},
            {"id": 2, "name": "Chatbot"}
        ]
    }

Purpose

Retrieves data from the server
Returns structured JSON response

Role in GenAI

Used to fetch: - stored responses
- model outputs
- system data

4. POST Endpoint – Sending Data

Request Flow

Send → Validate → Process → Respond

Pydantic Model

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_available: bool

This model defines the structure of the incoming data.

POST Endpoint Example

@app.post("/items")
def create_item(item: Item):
    return {
        "message": "Item received",
        "item": item
    }

Purpose

Receives user input
Validates data
Processes request
Returns response

Role in GenAI

POST requests are used to: - send prompts
- submit user input
- interact with AI models

5. Running the Server

Command

uvicorn main:app --reload

Explanation

Runs the FastAPI application
Makes the API accessible in the browser
--reload enables auto-restart on changes

ASGI Server

ASGI (Asynchronous Server Gateway Interface) allows handling multiple requests efficiently, making it suitable for modern applications.

6. Testing APIs with Swagger

What is Swagger?

Swagger is a tool that allows testing APIs directly from the browser without building a frontend.

Features

View all API endpoints
Test GET and POST requests
Send JSON input
View responses instantly

Swagger UI

Accessible at:

http://127.0.0.1:8000/docs

Example Request

{
  "name": "AI Tool",
  "price": 100,
  "is_available": true
}

Types of Swagger

Swagger UI → Interactive API testing interface
OpenAPI Specification → API structure in JSON format
ReDoc → Clean API documentation view

Final Thoughts

Building APIs is a key step in developing AI-powered applications.

GET endpoints → retrieve data
POST endpoints → send and process data
Pydantic → ensures data validation
Swagger → simplifies API testing

These components form the backbone of how AI systems interact with users and external services.

Day 1 – Python Foundations for GenAI

2026-04-13T00:00:00-03:00

Introduction

In Generative AI (GenAI), building models is only one part of the process. The real foundation lies in how we handle and structure data before it reaches the model.

To get started, I focused on three essential Python concepts:

Variables
Lists
Dictionaries

These form the backbone of how data flows in AI systems.

1. Variables – Storing Data

What are Variables?

Variables are used to store values that can be reused and modified throughout a program.

Common Data Types

int → whole numbers
float → decimal values
string → text data
boolean → True or False

age = 21
price = 99.99
name = "Arun"
is_active = True

Role in GenAI

In AI applications, variables are used to store: - user prompts
- model settings
- outputs and responses

prompt = "Explain Artificial Intelligence in simple terms"
temperature = 0.7

print(prompt)
print(temperature)

Variables help manage dynamic data in AI workflows.

2. Lists – Managing Collections

What are Lists?

Lists are ordered collections that can hold multiple values.

Types of Lists

Same type values:

numbers = [1, 2, 3, 4]

Mixed values:

data = ["AI", 2026, True]

Nested lists:

matrix = [[1, 2], [3, 4]]

Role in GenAI

Lists are useful for storing: - multiple inputs
- sequences of data
- conversation history

prompts = [
    "What is AI?",
    "Explain Machine Learning"
]

print(prompts[0])

prompts.append("Explain Deep Learning")
print(prompts)

They help maintain order and manage multiple values efficiently.

3. Dictionaries – Structuring Information

What are Dictionaries?

Dictionaries store data in key-value format, making it easy to organize and access information.

Examples

Basic dictionary:

user = {
    "name": "Arun",
    "age": 21
}

Nested structure:

user = {
    "name": "Arun",
    "details": {
        "age": 21,
        "city": "Chennai"
    }
}

Dictionary with list (common in AI):

data = {
    "messages": [
        {"role": "user", "content": "Hi"},
        {"role": "assistant", "content": "Hello"}
    ]
}

Role in GenAI

Dictionaries are critical because AI models expect structured input.

message = {
    "role": "user",
    "content": "Write a short story"
}

print(message["role"])
print(message["content"])

They define who is speaking and what is being communicated.

Combining Lists and Dictionaries

Real-world AI systems combine lists and dictionaries to represent conversations.

chat_history = [
    {"role": "user", "content": "Hello"},
    {"role": "assistant", "content": "Hi! How can I help?"},
    {"role": "user", "content": "Explain AI"}
]

print(chat_history[-1]["content"])

This structure is widely used in chat-based AI applications.

Final Thoughts

Understanding how to store and structure data is the first step in building AI systems.

Variables → hold values
Lists → manage sequences
Dictionaries → organize structured data

Together, they form the core data model behind modern GenAI applications.