And honestly, as I reached the end of this milestone, one thought echoed in my mind —

“It’s not the end of a beginning — it’s the beginning of something far more powerful.” ⚡

🧰 Understanding Tools — The Hands of an AI

In LangChain, tools are how an LLM interacts with the external world.
They’re not just “functions” — they are defined capabilities the model can call when it needs to act.

In my tools_in_langchain.ipynb notebook, I learned how to create custom tools using decorators and schemas — turning Python functions into intelligent callable components that LLMs can reason about.

🧩 Creating Tools in LangChain

Here’s the first tool I built 👇

from langchain.tools import tool

@tool
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

Each tool is wrapped with the @tool decorator, which does three key things:

1. Adds a structured name and description that the LLM can understand.

2. Defines an input/output schema, ensuring the model passes correct arguments.

3. Makes the tool discoverable by agents or LLMs using function calling.

These small pieces of functionality — whether it’s multiplication, greeting, or data lookup — become the building blocks of an agentic system.

⚙️ Why Tools Matter

Tools are what make AI useful in the real world.
Without them, models can only “talk” — with them, they can:

• Access APIs (weather, finance, search)

• Perform computations

• Retrieve external knowledge

• Trigger workflows or automations

This marks the transition from static text generation to interactive intelligence.

🔄 Tool Calling — When the Model Learns to Act

After defining tools, I moved to tool calling, which I explored in my tool_callling.ipynb notebook.

Tool calling is the mechanism that allows the model to:

• Read the user’s input

• Identify which tool to use

• Pass arguments automatically

• Execute it and return structured responses

Here’s the actual snippet I worked on 👇

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool

import os
model = ChatOpenAI(
    model=os.getenv("OPENROUTER_MODEL"),   
    api_key=os.getenv("OPENROUTER_API_KEY"),
    base_url="https://openrouter.ai/api/v1",  # Important: points to OpenRouter
    temperature=0.7,
    # max_tokens=400,
)
llm_with_tool=model.bind_tools([multiply])
query=HumanMessage('can you multiply 4 with 20')

result=llm_with_tool.invoke(query)

Here’s what’s happening step-by-step:

1. Model Setup (OpenRouter Integration) –
   The ChatOpenAI model is initialized using your OpenRouter API key and base URL (https://openrouter.ai/api/v1), allowing access to various LLMs hosted on OpenRouter.

2. Temperature Setting –
   The temperature=0.7 parameter controls creativity in responses; higher values make outputs more diverse, while lower values make them more deterministic.

3. Tool Binding –
   The line llm_with_tool = model.bind_tools([multiply]) connects a predefined tool (in this case, a function called multiply) to the LLM, enabling it to call that tool when needed instead of just generating text.

4. Creating a Human Message –
   query = HumanMessage('can you multiply 4 with 20') wraps the user’s input in a structured format that the model understands as a human prompt.

5. Model Invocation with Tool Use –
   When llm_with_tool.invoke(query) runs, the model interprets the query, recognizes it as a multiplication task, calls the bound multiply tool, and returns the computed result — demonstrating tool calling in LangChain.

That’s the magic — the model isn’t just generating; it’s deciding and acting.

🔍 Debugging the Flow

During my experiments, I also explored the model’s decision trace — where it explicitly outputs thoughts like:

“I will use the multiply tool to compute 4 ×20.”

This interpretability helps debug the agent’s reasoning steps and makes the process feel like watching an AI think in real time.

🧠 My First LangChain Agent — A Smart Tool-Using Assistant

After learning how to use tools and handle tool-calling in LangChain, I finally built my first fully functional Agent — a moment that truly marks “the end of a beginning” in my Agentic AI journey.

This agent can reason, plan, and take actions automatically using two real-world tools:

1. 🌍 DuckDuckGo Search Tool – for live information and factual lookups

2. 🌦 Custom Weather Tool – built using the WeatherStack API to fetch real-time weather data

⚙️ Step 1: Setting Up Tools

The first step was defining the tools that the agent could call as part of its reasoning process.

🔹 Web Search Tool

I initialized the DuckDuckGoSearchRun tool to help the agent perform live web searches.

from langchain_community.tools import DuckDuckGoSearchRun
search_tool = DuckDuckGoSearchRun()

🔹 Custom Weather Tool

Next, I created a custom tool using LangChain’s @tool decorator.
This tool connects to the WeatherStack API and fetches current weather data for any city.

from langchain_core.tools import tool
import requests
import os

api_key = os.getenv('WEATHER_STACK')

@tool
def get_weather(city: str) -> str:
    '''
    This function fetches current weather data for a city
    '''
    url = f'https://api.weatherstack.com/current?access_key={api_key}&query={city}'
    response = requests.get(url)
    return response.json()

This was a big step — I wasn’t just giving my model static knowledge; I was giving it real-world capabilities to act dynamically through APIs.

🧩 Step 2: Connecting the LLM

I used ChatOpenAI via OpenRouter, which provides access to multiple LLMs using a single endpoint.

from langchain_openai import ChatOpenAI

model = ChatOpenAI(
    model=os.getenv("OPENROUTER_MODEL"),   
    api_key=os.getenv("OPENROUTER_API_KEY"),
    base_url="https://openrouter.ai/api/v1",
    temperature=0.7,
)

The model will later be given permission to invoke these tools when necessary.

🧠 Step 3: Creating the Agent

LangChain provides a React (Reason + Act) agent that reasons about a query, decides which tools to use, and combines their results for a final answer.

I pulled a pre-built reasoning prompt from the LangChain Hub and used it to initialize my agent:

from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub

prompt = hub.pull("hwchase17/react")

agent = create_react_agent(
    llm=model,
    tools=[search_tool, get_weather],
    prompt=prompt
)

🚀 Step 4: Running the Agent Executor

Once the agent was ready, I wrapped it with AgentExecutor to manage its reasoning and tool-calling process:

agent_executor = AgentExecutor(
    agent=agent,
    tools=[search_tool, get_weather],
    verbose=True
)

input = "Find the capital of Maharashtra, then find its current weather condition"
response = agent_executor.invoke({"input": input})
print(response)

🧾 Output

When I executed the chain, the agent autonomously:

1. Used the DuckDuckGo search tool to find the capital of Maharashtra (Mumbai).

2. Then, invoked the get_weather tool to fetch the current weather in Mumbai.

The result was:

“The capital of Maharashtra is Mumbai. The current weather in Mumbai is 28°C with partly cloudy skies.”

response['output']
# Output: "The capital of Maharashtra is Mumbai. The current weather in Mumbai is 28°C with partly cloudy skies."

It was amazing to watch the model think step by step, use the right tools, and arrive at a grounded answer — a true first step into building autonomous AI systems.

🌟 Reflection

This was not just about writing code; it was about witnessing intelligence in action —
an AI system that doesn’t just predict text but decides what to do next.

As I closed my notebook that day, one phrase echoed in my mind:

“This is not the end — it’s the end of a beginning.”
Because from here onward, I’m moving from understanding how AI works to building AI that works intelligently on its own.

🔮 What’s Next

Next, I’ll dive into project implementations using LangChain — applying what I’ve learned to solve real-world problems.
After that, I’ll begin exploring LangGraph, to learn how to design production-ready agents that are more structured, reliable, and scalable.

If you’ve ever wondered how AI pipelines actually run under the hood — how your prompts, models, and parsers connect together — this is where all of that comes to life.

Today was all about understanding how LangChain structures flow, logic, and connections between its building blocks.

⚙️ Setting the Stage — Importing Essentials

Before I started experimenting, I ensured my environment was ready.
Here are the imports I used across all my runnable and chain examples:

from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain.schema.runnable import (
    RunnableSequence,
    RunnableParallel,
    RunnablePassthrough,
    RunnableLambda,
    RunnableBranch
)
from langchain.chains import SimpleChain, SequentialChain, ParallelChain
import os

load_dotenv()

With that done, I was ready to begin my deep dive.

🧩 Understanding Runnables — The Core Foundation

Runnables define how data moves between each component in a LangChain pipeline.
They are like the nervous system — sending information step-by-step through prompts, models, and parsers.

You can think of them as a manual approach to building custom dataflows before moving to more abstracted versions — Chains.

🔹 RunnableSequence — Building Step-by-Step Pipelines

This was my first hands-on runnable type.
It allowed me to connect multiple components where each step’s output becomes the next step’s input.

from langchain.schema.runnable import RunnableSequence

prompt1 = PromptTemplate(
    template="Generate a report on {topic}",
    input_variables=["topic"]
)

prompt2 = PromptTemplate(
    template="Summarize the following report into key points:\n{text}",
    input_variables=["text"]
)

model = ChatOpenAI(model=os.getenv("OPENROUTER_MODEL"),
                   api_key=os.getenv("OPENROUTER_API_KEY"),
                   base_url="https://openrouter.ai/api/v1")

parser = StrOutputParser()

sequence = RunnableSequence(first=prompt1, middle=[model, parser, prompt2, model, parser])
result = sequence.invoke({"topic": "Artificial Intelligence in Healthcare"})

print(result)

This created a multi-step pipeline where a report was first generated and then summarized — showing how easily one can connect multiple logical stages.

⚖️ RunnableParallel — Running Tasks Simultaneously

Sometimes, you don’t want to wait for one task to complete before starting another.
That’s where RunnableParallel shines — it executes multiple branches at the same time and returns all results together.

prompt_notes = PromptTemplate(
    template="Create quick notes from this paragraph:\n{text}",
    input_variables=["text"]
)

prompt_quiz = PromptTemplate(
    template="Generate 3 quiz questions from this paragraph:\n{text}",
    input_variables=["text"]
)

parallel = RunnableParallel({
    "notes": RunnableSequence(first=prompt_notes, middle=[model, parser]),
    "quiz": RunnableSequence(first=prompt_quiz, middle=[model, parser])
})

text = "Reinforcement learning is a feedback-driven approach to machine learning."
result = parallel.invoke({"text": text})

print(result)

This parallel structure was powerful — it helped me realize how models can multitask efficiently.

🔁 RunnablePassthrough — Sending Inputs as Is

This simple but useful runnable just passes the input forward.
I used it for debugging and maintaining context during pipeline testing.

from langchain.schema.runnable import RunnablePassthrough

passthrough = RunnablePassthrough()
print(passthrough.invoke("Hello, Runnables!"))

⚡ RunnableLambda — Adding Custom Logic

Sometimes you need small transformations — for example, formatting or cleaning the data before passing it ahead.
That’s where RunnableLambda came in handy.

from langchain.schema.runnable import RunnableLambda

to_upper = RunnableLambda(lambda x: x.upper())
print(to_upper.invoke("agentic ai"))

🌿 RunnableBranch — Bringing Conditional Logic

This was one of the most exciting concepts — adding decision-making capability.
You can route data differently based on conditions, making workflows adaptive.

For instance, based on input sentiment, you can route text to either a summarizer or a sentiment analyzer model.

tech_prompt = PromptTemplate(template="Explain the technology behind {topic}.", input_variables=["topic"])
nontech_prompt = PromptTemplate(template="Give a short overview of {topic}.", input_variables=["topic"])

branch = RunnableBranch(
    (lambda x: "AI" in x["topic"], RunnableSequence(first=tech_prompt, middle=[model, parser])),
    (lambda x: True, RunnableSequence(first=nontech_prompt, middle=[model, parser]))  # default
)

print(branch.invoke({"topic": "AI in healthcare"}))
print(branch.invoke({"topic": "Global tourism"}))

🔗 From Runnables to Chains

Once I grasped Runnables, I moved to Chains — which are built on top of them.
Chains make the code simpler and more readable while maintaining the same power and flexibility.

If Runnables are the manual gearbox, Chains are the automatic transmission — smoother, faster, and easier to manage.

🔹 Simple Chain

The SimpleChain is where it all begins.
It connects a single input, a single model, and an output parser in a neat and easy way.

prompt = PromptTemplate(template="What are the key advantages of {topic}?", input_variables=["topic"])

simple_chain =prompt | model | parser)

It’s the most beginner-friendly way to execute a single model pipeline.

🔸 Sequential Chain

The SequentialChain is similar to RunnableSequence but more structured and readable.
Each chain executes in order and passes its output to the next one.

prompt1 = PromptTemplate(template="Write a paragraph about {topic}.", input_variables=["topic"])
prompt2 = PromptTemplate(template="Summarize the following text:\n{text}", input_variables=["text"])

chain1 = prompt1| model| parser
chain2 = prompt2| model|parser

sequential_chain = chain1|chain2

This chain type is perfect for step-by-step transformations like text generation, cleaning, and summarization.

⚖️ Parallel Chain

Parallel chains execute multiple sub-chains simultaneously and return combined results.
They’re useful when one input needs to produce multiple kinds of outputs.

from langchain.chains import RunnableParallel

prompt_a = PromptTemplate(template="Summarize this:\n{text}", input_variables=["text"])
prompt_b = PromptTemplate(template="Generate 3 questions from this text:\n{text}", input_variables=["text"])

chain_a = prompt_a |model| parser
chain_b = prompt_b|model|parser

parallel_chain = RunnableParallel( chain_a|chain_b)

🔀 Conditional Chain

Conditional chains help route inputs based on specific criteria.
For example, if a topic is technical, send it to one model; otherwise, use another.

This kind of conditional flow makes AI workflows smarter and more adaptable.

prompt_tech = PromptTemplate(template="Write a technical summary of {topic}.", input_variables=["topic"])
prompt_general = PromptTemplate(template="Write a general summary of {topic}.", input_variables=["topic"])

tech_chain = SimpleChain(prompt=prompt_tech, llm=model, output_parser=parser)
general_chain = SimpleChain(prompt=prompt_general, llm=model, output_parser=parser)

def route_topic(input_data):
    return "tech_chain" if "AI" in input_data["topic"] else "general_chain"

conditional_chain = ConditionalChain(
    input_key="topic",
    condition_function=route_topic,
    chains={"tech_chain": tech_chain, "general_chain": general_chain}
)

🌳 Branch Chain

Finally, I learned about the BranchChain, where multiple paths can exist, and execution follows a branch based on predefined logic.
It’s like giving your chain a decision tree inside it.

prompt_ai = PromptTemplate(template="Provide a detailed explanation of {topic} in AI terms.", input_variables=["topic"])
prompt_finance = PromptTemplate(template="Explain {topic} with examples from finance.", input_variables=["topic"])
prompt_default = PromptTemplate(template="Give a brief description of {topic}.", input_variables=["topic"])

ai_chain = SimpleChain(prompt=prompt_ai, llm=model, output_parser=parser)
finance_chain = SimpleChain(prompt=prompt_finance, llm=model, output_parser=parser)
default_chain = SimpleChain(prompt=prompt_default, llm=model, output_parser=parser)

def branch_logic(inputs):
    topic = inputs["topic"].lower()
    if "ai" in topic:
        return "ai_chain"
    elif "finance" in topic:
        return "finance_chain"
    else:
        return "default_chain"

branch_chain = BranchChain(branch_function=branch_logic, branches={
    "ai_chain": ai_chain,
    "finance_chain": finance_chain,
    "default_chain": default_chain
})

print(branch_chain.run({"topic": "AI in marketing"}))
print(branch_chain.run({"topic": "Investment banking"}))
print(branch_chain.run({"topic": "Climate change"}))

💡 My Takeaway

Day 11 was a real “aha!” moment for me.
I finally understood how LangChain manages flow, execution, and decision-making.

Runnables gave me raw control — allowing me to piece components together.
Chains added structure — turning that complexity into readable, reusable logic.

This balance between flexibility and simplicity makes LangChain truly special.

So, on Day 10, I decided to solve that problem by learning about Structured Outputs and Output Parsers in LangChain — tools that make model outputs consistent, predictable, and machine-readable.

🧩 Why Structured Outputs Matter

When you’re building AI systems that connect to other applications — like dashboards, databases, or APIs — you can’t rely on loosely formatted text.
Structured outputs ensure the model’s responses follow a defined schema — such as JSON, Pydantic objects, or TypedDicts — so they can be parsed and used programmatically.

In simpler terms:

“Structured Outputs turn AI responses from creative text into usable data.”

🔹 Enforcing Structure with with_structured_output

LangChain provides a method called with_structured_output that binds a model’s output to a predefined schema.

I practiced this with three different approaches:

1. TypedDict – Lightweight Python typing for dictionaries.

2. Pydantic BaseModel – Strict validation and type enforcement.

3. Raw JSON Schema – Fully custom JSON structures for flexibility.

Each method gave me a better understanding of how to enforce structure depending on project needs.

🧱 Designing a Schema: The Review Example

To understand this better, I designed a Review Schema that extracts:

key_themes: list[str]=Field(description='Write down all the key themes discussed in the review in a list')
summary:str=Field(description='a brief overview of the review')
sentiment:Literal['pos','neg']= Field(description='return sentiment of review either positive or negative')
pros:Optional[list[str]]=Field(default=None,description='Write down all the pros inside the list')
cons:Optional[list[str]]=Field(default=None,description='Write all the cons inside a list')
name:Optional[list[str]]=Field(description='Write name of the reviewer')I added field descriptions to guide the model toward more accurate extraction.

I added field descriptions to guide the model toward more accurate extraction.

Example:

Literal['pos','neg']= Field(description='return sentiment of review either positive or negative')

However, my schema description mentioned “neutral,” while the enum only allowed “pos” or “neg.”
🔍 This mismatch taught me a key production lesson — schema descriptions must align with their definitions to avoid validation errors.

I also made pros, cons, and name optional fields to ensure the parser remained robust even when those values were missing in text.

⚙️ Backend Portability in Action

Another big learning moment was discovering that the structured output workflow is backend-agnostic.
I seamlessly swapped between:

• ChatOpenAI

• ChatHuggingFace

…and the same structured output logic worked perfectly.

This portability shows the true power of LangChain’s abstraction — one schema can run across multiple LLM backends without rewriting logic.

🧠 Hugging Face + Structured Outputs

For experimentation, I used:

• TinyLlama/TinyLlama-1.1B-Chat-v1.0 via HuggingFaceEndpoint

• google/gemma-2-2b-it for consistency testing across different parser patterns

I also used load_dotenv() to keep environment variables (like API keys) out of the source code — a simple but essential best practice.

🔄 The Operator Style: Template → Model → Parser

One of my favorite learnings was how LangChain lets you compose runnable chains using the operator-style syntax:

template | model | parser

This design makes your workflow clean and readable, returning Python-native structures directly.

I also learned to use parser.get_format_instructions() inside partial_variables to instruct the model exactly how to structure the JSON output — minimizing hallucinations and formatting errors.

🧾 Working with Different Parsers

Here’s what I practiced and compared:

1. JsonOutputParser

• Converts free-form text into strict machine-readable JSON.

• Eliminates the need for fragile regex post-processing.

• Perfect for prompts like “List 5 facts about AI.”

2. ResponseSchema + StructuredOutputParser

• Enforces named fields like fact_1, fact_2, etc.

• Produces well-structured Python dictionaries for easy access.

3. PydanticOutputParser

• Allows defining custom validation logic using Pydantic models.

• I even added a condition to ensure age > 18 — a great exercise in constraint enforcement.

4. StrOutputParser

• Parses simple string outputs from models.

• Helped me understand when plain strings suffice and when structured parsing is better.

🧩 Retrieving and Using Structured Results

Once parsed, I could easily access individual elements like:

print(result["name"])

This made working with model outputs feel just like handling any other Python data structure.

I also set Hugging Face’s task as "text-generation" consistently while creating endpoints — an important configuration step to ensure clean text-based results.

💡 Best Practices I Picked Up

• Use with_structured_output for reliability — it binds schema and parsing in one step.

• Keep schema descriptions clear and consistent.

• Use environment variables to protect sensitive data.

• Prefer JSON or Pydantic parsers when you need non-tool-based structured data extraction.

• Always validate the final structure before using it in downstream tasks.

🔑 Key Takeaways from Day 10

✔ Learned multiple approaches to enforce structured outputs using TypedDict, Pydantic, and JSON schema.
✔ Designed a robust Review schema and understood schema-description mismatches.
✔ Explored backend portability between OpenAI and Hugging Face.
✔ Practiced output parsing with Json, Pydantic, Structured, and String parsers.
✔ Built end-to-end runnable chains with template | model | parser.
✔ Ensured clean, machine-readable outputs ready for production use.

📌 What’s Next?

Day 10 gave me a deeper understanding of how to make AI outputs structured, reliable, and production-ready — something every GenAI developer needs before building real-world systems.

Next, in Day 11, I’ll explore Runnables and Chains in LangChain ⚙️

I’ll dive into how these components allow developers to:

• Combine models, prompts, and parsers into modular pipelines.

• Build flexible, maintainable workflows that can scale.

• Link multiple steps — like input processing, model inference, and output parsing — into one smooth chain.

This will take me one step closer to mastering the core building blocks of Agentic AI, where multiple reasoning and decision-making components work together seamlessly.

Stay tuned for Day 11 — we’re moving from structured outputs to structured thinking 🚀

On Day 9, I explored two of the most important components of LangChain:

1. Models – the core brains of the system.

2. Prompts – the way we guide and control these brains.

And to make my learning more exciting, I also built a mini project that uses prompts to summarize research papers. Let’s dive in.

🔹 Working with Models in LangChain

Models are at the heart of LangChain. They power everything — from chatbots to summarizers to advanced RAG pipelines. On Day 9, I learned about different categories of models and how LangChain makes it easy to switch between them.

Proprietary vs. Open-Source Models

• Proprietary Models: OpenAI’s GPT, Anthropic’s Claude, Google’s Gemini.

  • Require an API key and are often paid.

  • Highly optimized for accuracy and fluency (using RLHF and fine-tuning).

  • LangChain makes switching between providers as simple as changing the import class.

• Open-Source Models: Hugging Face hosts models like LLaMA, Zephyr, TinyLlama.

  • Free and customizable.

  • Can be run using Hugging Face Inference API or locally.

  • Running locally requires more hardware but gives full control.

As a student, I focused more on open-source models while still making sure I understood how to use proprietary ones.

Hugging Face Inference API

I started by using Hugging Face’s Inference API with the Zephyr-7B-beta model.

from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
from dotenv import load_dotenv
import os
load_dotenv()

llm = HuggingFaceEndpoint(
    repo_id="HuggingFaceH4/zephyr-7b-beta",
    task="text-generation",
    max_new_tokens=200,
    temperature=0.7,
    huggingfacehub_api_token=os.getenv("HUGGINGFACEHUB_API_TOKEN")
)

model = ChatHuggingFace(llm=llm)
result = model.invoke("What is the capital of India")
print(result.content)

✅ Output: “New Delhi, but Mumbai is the largest city in terms of population…………………..”

🔎 Why this happens:
Unlike proprietary models (like GPT), many open-source models are trained on general datasets and may add extra context instead of giving a short, direct answer. This makes them useful for richer responses but sometimes less precise.

Running Models Locally

Next, I tried running a smaller model (TinyLlama-1.1B-Chat) on my laptop:

from langchain_huggingface import ChatHuggingFace, HuggingFacePipeline
import os

os.environ['HF_HOME']=r"D:\Programming\GEN-AI\Campus x Gen AI with langchain\huggingface_cache"

llm=HuggingFacePipeline.from_model_id(
    model_id="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
    task="text-generation",
    pipeline_kwargs=dict(
        temperature=0.6,
        max_new_tokens=100
    )
)

model=ChatHuggingFace(llm=llm)
result=model.invoke('What is capital of india? ')
print(result.content)

✅ Output: {

<|user|> What is capital of india?

<|assistant|> The capital of India is New Delhi, also known as "Lal Qila" or "Red Fort".

}

🔎 Observation:
Surprisingly, the locally run model gave a more precise and enriched answer compared to the Hugging Face API run. This shows that local fine-tuned models can sometimes provide contextually sharper results — though they may be slower and require more system resources.

Creating Embeddings with Hugging Face

Alongside LLMs, I also learned to create embeddings, which are vectors that represent the meaning of text.

from langchain_huggingface import HuggingFaceEmbeddings

embedding = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')

doc = [
    'Delhi is capital of India',
    'Kolkatta is capital of India',
    'Paris is capital of France'
]

vector = embedding.embed_documents(doc)
print(str(vector))

✅ Output: Dense vectors for each sentence.

This step helped me understand how embeddings allow AI systems to compare meanings beyond exact words — an essential part of building semantic search and RAG applications.

🔹 Working with Prompts in LangChain

Once I got comfortable with models, I moved on to Prompts.

Prompts are the way we “talk” to models, and LangChain gives us structured tools to manage them.

Structured Prompting

Here’s what I learned:

1. Prompt Templates → Reusable text structures with placeholders.

   • Example: "Translate the following text into French: {text}".

2. Chat Prompt Templates → For conversations with role separation.

   • System Message → Defines AI’s role (e.g., “You are a helpful tutor”).

   • Human Message → User’s input.

   • AI Message → Model’s response.

3. Message Placeholders → Allow dynamic insertion of chat history or context (e.g., {history}).

   • Super useful for chatbots and memory-based apps.

Example: Simple Prompt

from langchain_core.prompts import PromptTemplate

template = PromptTemplate.from_template("Translate the following text into French: {text}")

prompt = template.format(text="I love learning AI with LangChain")
print(prompt)

✅ Output:

Translate the following text into French: I love learning AI with LangChain

Why Prompts Matter

• They control how the AI behaves.

• They can be reused and scaled.

• Structured roles (System/Human/AI) make interactions more natural.

• Placeholders make prompts dynamic and flexible.

🛠️ My Mini Project: Research Paper Summarizer

After learning about prompt templates, I built my first mini-project — a tool to summarize research papers 🎓.

Here’s what I did:

1. Created a prompt and saved it as a JSON file (template.json).

   • This ensured the instructions were reusable.

2. Took user inputs (paper title, explanation style, summary length).

3. Generated summaries with math details, analogies, and proper structure.

Example Prompt

template= PromptTemplate(
    template='''
Please summarize the research paper titled "{paper_input}" with the following specifications:
Explanation Style: {style_input}  
Explanation Length: {length_input}  
1. Mathematical Details:  
   - Include relevant mathematical equations if present in the paper.  
   - Explain the mathematical concepts using simple, intuitive code snippets where applicable.  
2. Analogies:  
   - Use relatable analogies to simplify complex ideas.  
If certain information is not available in the paper, respond with: "Insufficient information available" instead of guessing.  
Ensure the summary is clear, accurate, and aligned with the provided style and length.
''',
    input_variables=['paper_input','style_input','length_input'],
    validate_template=True
)

template.save('template.json')

This project showed me how prompts can be reusable assets for building real-world GenAI applications.

🔹 GitHub Repository

You can find the code for my project here 👇
👉 GitHub Repository Link

🔑 Key Learnings from Day 9

• Learned how to integrate both proprietary and open-source models in LangChain.

• Practiced with Hugging Face API and local models.

• Generated embeddings for semantic tasks.

• Explored prompt engineering with templates, roles, and placeholders.

• Built my first mini-project with prompts (research paper summarizer).

📌 What’s Next?

Day 9 was packed with hands-on learning — from exploring models and embeddings to mastering prompts and even building my first mini-project. I can already see how these foundational skills are building me up toward real-world Agentic AI applications.

For Day 10, I’ll be diving into another powerful feature of LangChain:

🔹 Structured Outputs & Parsers

• How to make model outputs more predictable and machine-readable.

• Using parsers to convert free-form text into structured formats like JSON or Pydantic objects.

• Why structured outputs are essential for integrating LLMs into larger workflows and pipelines.

This is going to be a big step in making my AI applications production-ready rather than just experiments.

So stay tuned for Day 10 🚀

On Day 8, I finally started exploring LangChain — a framework that is quickly becoming one of the most powerful tools for building real-world AI applications.

🔹 What is LangChain?

LangChain is an open-source framework designed to simplify the process of creating applications powered by Large Language Models (LLMs).

Why is it so useful? Let’s take an example. Imagine you want to build a PDF chatbot that lets you “talk” to your documents. To make that possible, you’d need to:

• Load documents from a source.

• Break them into smaller, manageable chunks.

• Convert those chunks into embeddings.

• Store embeddings in a database.

• Perform semantic search to retrieve relevant pieces.

• Send them to an LLM for response.

Doing all this manually would be complex and time-consuming. This is where LangChain shines. It acts as the orchestrator, connecting all these parts seamlessly and giving developers a plug-and-play pipeline for LLM applications.

🔹 Why LangChain Matters in My Journey

For me, learning LangChain felt like crossing a bridge — from theory to practice. It showed me how the concepts I’ve been learning (like embeddings, vector databases, and RAG) fit together to actually build applications.

And the best part? LangChain is model-agnostic. That means I can switch between OpenAI, Anthropic, Google, or Hugging Face models without rewriting the core of my application.

🔹 The Six Core Components of LangChain

On Day 8, I studied LangChain’s six building blocks. These components make it modular, flexible, and extremely powerful.

1. Models

The foundation. LangChain standardizes communication with different language models and embedding models. No matter which provider you use, the interface stays consistent.

2. Prompts

I learned how prompts are central to guiding LLMs. LangChain lets you create:

• Dynamic prompts with placeholders.

• Role-based prompts (e.g., “You are an experienced doctor”).

• Few-shot prompts to teach new tasks with examples.

3. Chains

The heart of LangChain. Chains let you connect tasks into a logical pipeline where the output of one step becomes the input of the next.

• Sequential Chains: simple pipelines.

• Parallel Chains: run tasks simultaneously.

• Conditional Chains: change flow based on conditions.

4. Indexes

Indexes let LLMs access external knowledge. They combine:

• Document Loaders (to bring in data).

• Text Splitters (to chunk it).

• Vector Stores (to store embeddings).

• Retrievers (to fetch relevant chunks).

This enables Retrieval-Augmented Generation (RAG) — something I had only read about earlier, but now started connecting with actual frameworks.

5. Memory

Normally, LLMs are stateless. But LangChain adds memory, so models can “remember” past interactions and carry forward context. I explored different memory types like buffer memory, window memory, and summarizer-based memory.

6. Agents

This was the most exciting part. Unlike normal chatbots, agents can take actions. They use reasoning + tools to complete tasks. For example, a LangChain agent could not only tell you flight prices but also book the flight using an API.

🔹 Applications I Can Imagine Building

LangChain unlocked my imagination. Some use cases I now see clearly are:

• Conversational Chatbots for support.

• AI Assistants trained on private documents.

• Research Summarizers to digest papers.

• Workflow Automations using LLMs + tools.

• AI Agents that don’t just answer — but act.

✨ Key Takeaways from Day 8

• LangChain is the bridge between theory and practice in Generative AI.

• Its modular components (Models, Prompts, Chains, Indexes, Memory, Agents) give developers superpowers.

• With LangChain, building scalable, production-ready AI apps becomes accessible.

🔮 What’s Next (Day 9 Preview)

On Day 9, I’ll continue with LangChain and dive into its practical side. I’ll explore how to actually implement Chains, Memory, and Agents with small projects. The goal is to apply what I’ve learned and see these components come alive in action.

Stay tuned — the journey is now moving into hands-on GenAI development 🚀.

🔹 Large Language Models (LLMs) vs Instruction-Tuned Models

• LLMs (like GPT-3, GPT-4): trained on massive datasets, good for general text generation.

• Instruction-Tuned Models: fine-tuned with supervised instruction-response datasets, making them better at following commands and solving specific tasks like summarization, translation, or coding.

Some notable models: Flan-T5, Flan-PaLM, BloomZ.

🔹 Fine-Tuning Techniques

• Full Fine-Tuning: updates all model parameters, leading to high task specialization but costly and risks catastrophic forgetting.

• Parameter-Efficient Fine-Tuning (PEFT): adapts models with minimal changes to parameters using adapters.

• LoRA (Low-Rank Adaptation): a smart way to fine-tune only a small fraction of parameters while maintaining performance.

🔹 Model Evaluation

I learned about how models are evaluated:

• Qualitative evaluation: human judgment for fluency & relevance.

• Quantitative metrics:

  • ROUGE (precision, recall, F1 on n-gram overlaps).

  • BLEU & METEOR for translation & text generation tasks.

🔹 Case Study: Dialogue Summarization

Using Flan-T5, I explored prompt engineering methods (zero-shot, one-shot, few-shot). The results showed that while prompts help, fine-tuning or PEFT is necessary for high-quality outputs.

✨ Key Takeaways from Day 7

• Instruction tuning makes LLMs task-focused and user-friendly.

• PEFT and LoRA are game changers for efficient fine-tuning.

• Evaluation metrics like ROUGE, BLEU, METEOR are crucial to measure effectiveness.

🔮 What’s Next (Day 8 Preview)

On Day 8, I’ll dive into LangChain — one of the most powerful frameworks for building real-world Generative AI applications.

Here’s what I’ll be exploring:

• Introduction to LangChain – what it is and why it’s important in the GenAI ecosystem.

• Core Components of LangChain:

  • Prompt Templates – structuring and reusing prompts effectively.

  • Chains – linking multiple LLM calls together.

  • Memory – enabling models to retain context across interactions.

  • Agents – allowing dynamic decision-making using tools.

  • Toolkits & Integrations – extending LangChain to databases, APIs, and more.

✨ Day 8 will be all about moving from theory to tools, learning how LangChain helps in building scalable, production-ready AI apps.

Hello everyone, welcome back to Day 6 of my journey toward mastering Agentic AI.
On the previous days, I built my foundation by learning NLP, RNNs, Attention, and Transformers. Today, I shifted gears to explore something that sits at the intersection of AI research and product development — the Generative AI Product Life Cycle.

This was a new perspective for me — not just understanding how AI models work, but also how they’re taken from an idea to deployment in real-world applications. Alongside this, I also dived into supporting concepts like prompt engineering, Hugging Face, LangChain, and Retrieval-Augmented Generation (RAG).

Here’s how my learning unfolded today 👇

🔑 Step 1: Identify the Use Case

The first step in any Gen AI product is identifying the right use case.
Without a clear use case, even the most advanced models won’t deliver value.

Some common use cases I studied were:

• Text Generation → blogs, articles, marketing content.

• Conversational AI → chatbots & virtual assistants.

• Text Summarization → turning large documents into concise insights.

• Sentiment Analysis → understanding customer emotions in reviews.

• Translation & TTS → breaking language barriers and enabling accessibility.

• Code Generation → helping developers with snippets.

👉 The key takeaway here: the problem must be well-defined before moving to models.

🔑 Step 2: Choosing the Right Foundation Model

Once the use case is clear, the next challenge is choosing a model.
Here, I learned to compare:

• Proprietary models (like GPT-4, Gemini) → optimized but costly & closed.

• Open-source models (like LLaMA, Mistral) → flexible, customizable, but need resources.

Also, the choice depends heavily on data type:

• Text → GPT family, LLaMA.

• Image → DALL·E, Midjourney.

• Audio → Whisper.

• Multimodal → GPT-4 Turbo with Vision, GPT-4o.

💡 Pro tip I picked up: Hugging Face LLM Leaderboard is a fantastic tool to explore and compare models.

🔑 Step 3: Prompting & Tuning

This step was super exciting because I’ve been practicing prompts myself.
There are three main techniques:

• Prompt Engineering → crafting clear, specific prompts.

• Instruction Tuning → fine-tuning with datasets aligned to tasks.

• Fine-Tuning (Full or PEFT) → adapting large models efficiently without retraining everything.

I also realized prompt engineering is an art 🎨. The clarity, context, and structure of the prompt make or break the result.

🔑 Step 4: Evaluation

Even after tuning, the model must be tested rigorously.
Metrics include:

• Accuracy

• Coherence

• User satisfaction

This step ensures the model doesn’t just work in theory but also in real-world conditions.

🔑 Step 5: Deployment

Finally, deployment! 🚀
This involves:

• Integrating the model into production.

• Ensuring scalability & monitoring.

• Continuous improvements (since models can drift or degrade).

Beyond the Cycle – Supporting Concepts I Explored

🌟 Hugging Face

A community hub for AI models where developers share, fine-tune, and explore models organized by tasks (text, vision, audio, multimodal). The concept of model cards impressed me — they provide transparency into training data, performance, and limitations.

🌟 Prompt Engineering in Action

I explored real-world examples like:

• Summarization

• Sentiment analysis

• Automated ticketing systems

• Chatbots

• Even product descriptions

It amazed me how changing just the wording of a prompt changes the entire output.

🌟 ArtificialAnalysis.ai

A benchmarking site that compares models on quality, speed, cost, and coding ability. I learned GPT-4o leads in reasoning but Gemini 1.5 Flash is faster and cheaper — great insight for product decisions.

🌟 Retrieval-Augmented Generation (RAG)

RAG solves the limitation of static training by letting models retrieve external knowledge before generating answers.
It works through:

1. Preparing & chunking data

2. Indexing embeddings in a vector database

3. Retrieving relevant chunks

4. Generating answers with enriched context

This ensures models stay accurate and up-to-date.

🌟 LangChain

A powerful framework to build LLM-powered apps with tools like:

• Prompt templates

• Memory systems (buffer, summary, token)

• Agents & tools

• Chains (sequential, router chains)

I saw how LangChain helps create real-world apps like chatbots, Q&A systems, and multi-step pipelines.

⚡ Key Takeaways from Day 6

1. Building AI products is not just about models — it’s about choosing use cases, models, and deployment strategies wisely.

2. Prompt engineering and fine-tuning are essential skills for any AI practitioner.

3. Platforms like Hugging Face, ArtificialAnalysis.ai, and LangChain are must-know tools for the AI ecosystem.

4. RAG and vector databases open up possibilities to make AI systems more reliable and domain-specific.

🔮 What’s Next? (Day 7 Preview)

On Day 7, I’ll continue exploring the Generative AI Product Lifecycle, this time focusing on fine-tuning and responsible AI. Some of the key areas I’ll cover include:

• Instruction-Tuned and Fine-Tuned Models → how models are adapted to follow specific instructions.

• Full Fine-Tuning → retraining models with large datasets.

• Parameter-Efficient Fine-Tuning (PEFT) → making fine-tuning faster and lighter.

• LoRA (Low-Rank Adaptation) → a practical PEFT technique.

• Evaluation Techniques → ensuring tuned models perform well.

• Project Lifecycle Analysis → comparing Instruction Tuning, Fine-Tuning, and PEFT approaches.

• Limitations, Challenges, and Responsible AI → exploring biases, ethical issues, and risks.

• Environmental Concerns → the impact of training large models.

Day 7 will help me understand how models move from general-purpose to highly specialized tools while balancing performance, efficiency, and responsibility.

Closing Thoughts

Today’s session was an eye-opener 🤯 — learning not just about models but also the ecosystem of tools and lifecycle stages that power real-world AI applications.

This journey is getting more exciting each day. Stay tuned for Day 7, and as always, I’d love to hear your suggestions, feedback, or resources that could help me learn better.

Let me walk you through what I learned on Day 5.

🔍 Introduction to LLMs

I started with the basics—what are Large Language Models?

LLMs are AI systems trained on massive datasets to predict the next word in a sequence. They learn grammar, semantics, and even real-world facts by processing billions of words. What makes them “large” are the billions of parameters they hold—internal variables fine-tuned during training to improve predictions.

Their capabilities blew me away:

• Generate essays, code, and poetry.

• Translate languages.

• Hold human-like conversations.

• Power applications in business, education, and beyond.

Of course, they come with challenges too—like environmental costs, bias, and ethical risks.

🏗️ Transformer Architecture – The Backbone

The Transformer is the architecture that made LLMs possible. It relies on:

• Tokenization → breaking text into tokens.

• Embeddings → turning tokens into vectors with meaning.

• Attention → letting the model focus on the most relevant parts of the input.

This architecture is what allows LLMs to capture long-range context with speed and accuracy.

📈 Why Transformers Took Over

I then learned why Transformer models are trending everywhere:

• Self-supervised learning makes them trainable on unlabeled data.

• Parallel processing speeds up training compared to RNNs.

• Scalability supports billions of parameters for complex tasks.

• Fine-tuning makes them adaptable to specific applications.

No wonder every major AI model today—from GPT to BERT—relies on Transformers.

🔑 GPT and Decoder-Only Models

Unlike the traditional encoder-decoder Transformer, GPT uses only the decoder.

• It relies on masked self-attention, predicting the next token without peeking ahead.

• Simplicity makes it efficient and great for training on unlabeled text.

• Surprisingly, it can still perform translation, summarization, and Q&A—thanks to its strong autoregressive training.

This was a big “aha!” moment for me: simplicity can be powerful.

🏛️ Foundation Models – A Timeline of Progress

I came across the evolution of foundation models—large-scale pre-trained models adaptable to many tasks. Some highlights:

• GPT-1 (2018): 117M parameters – the first step.

• BERT (2018): excelled at bidirectional understanding.

• GPT-2, GPT-3: scaling up to billions of parameters.

• BLOOM, LLaMA, Claude, Gemini, Mistral: pushing multilingual, ethical, and multimodal capabilities.

• GPT-4 and Claude 3: state-of-the-art, still evolving.

Each model represents a leap in scale, performance, and application reach.

⚙️ LLM Characteristics

I explored the core traits of LLMs:

• Versatile → handle translation, Q&A, coding.

• Stateless → no memory between queries.

• Stochastic → outputs vary with randomness.

• Memorizing vs. Learning → they balance generalization with memorized knowledge.

This helped me see why the same prompt can give different responses each time—it’s built into their design.

🌱 Emergent Abilities

A fascinating concept: emergent abilities.
These are skills that only appear in larger models—like better contextual understanding or creativity—even though smaller models can’t do them. They weren’t explicitly programmed but emerged as models scaled up.

It made me realize: scaling doesn’t just mean “more capacity,” it can unlock entirely new behaviors.

🎛️ OpenAI Playground – Experimenting with Models

I discovered OpenAI Playground, a space where anyone can test LLMs with different parameters:

• Temperature → controls randomness/creativity.

• Top-k vs Top-p sampling → balance between coherence and diversity.

• Max tokens → limit output length.

This was exciting—it means we can shape outputs for specific needs, whether creativity or precision.

💡 Real-World Example: Microsoft Copilot

I ended the day with Microsoft Copilot, an AI-powered assistant embedded into Microsoft tools. By adjusting parameters like temperature, Copilot can be:

• Creative (for brainstorming).

• Balanced (for general productivity).

• Precise (for technical tasks).

This showed me how LLMs are not just research experiments—they’re changing how we work every day.

🔮 What’s Next? (Day 6 Preview)

On Day 6, I’ll build on these concepts with hands-on applications of Generative AI and LLMs. Topics include:

• GenAI Project Lifecycle.

• Identifying use cases.

• Choosing foundation models/LLMs.

• Prompt engineering & optimization.

• Tools like Hugging Face, ArtificialAnalysis.ai, and LangChain.

• Advanced techniques like RAG (Retrieval Augmented Generation) and Vector Databases.

• LangChain concepts: memory, chaining, and chunking strategies.

Day 6 promises to be about making LLMs practical and project-ready 🚀.

✨ Final Thoughts

Day 5 helped me tie together everything I’ve learned so far. I now see how Transformers and LLMs form the core infrastructure of modern AI, powering everything from chatbots to copilots.

It feels like I’ve moved from learning “how models work” to seeing why they matter in the real world.

👉 What do you think about the rise of LLMs? Do you see them as tools, partners, or something more?

Stay tuned—Day 6 is where theory meets application! 🚀

This session really helped me frame where Agentic AI fits into the entire AI ecosystem. Let me walk you through what I learned.

🌟 ANI vs AGI – Narrow vs General Intelligence

The journey started with a fundamental comparison:

• Artificial Narrow Intelligence (ANI): This is where we are today. AI systems specialized for specific tasks — like spam filters, recommendation engines, or even GPT-4 when used for a particular purpose.

• Artificial General Intelligence (AGI): The holy grail of AI. A system that can perform any intellectual task like a human, showing reasoning, adaptability, and creativity across domains.

And here’s the catch: Generative AI is acting as a bridge from ANI towards AGI. By producing human-like text, images, and even multimodal outputs, GenAI is showing early glimpses of what versatile, human-level intelligence might look like.

🔄 AI, ML, DL, and GenAI – Untangling the Layers

The next concept cleared a lot of confusion for me. Often, AI-related terms are thrown around interchangeably, but there’s actually a clear hierarchy:

1. AI (Artificial Intelligence): The broadest field — making machines “think” like humans.

2. ML (Machine Learning): A subset of AI, focused on algorithms that learn from data.

3. DL (Deep Learning): A subset of ML that uses deep neural networks to uncover patterns from raw data.

4. GenAI (Generative AI): A subset of DL, where models don’t just analyze but create new content — text, images, code, music, and more.

This structure gave me clarity: Agentic AI will rely heavily on GenAI, since its decision-making depends on both understanding and generating content in real time.

⚖️ Discriminative vs Generative AI

I then explored two major approaches to AI:

• Discriminative AI: Learns boundaries between classes to classify data. (e.g., spam vs. non-spam email).

• Generative AI: Learns the distribution of the data to generate new data similar to it (e.g., creating a new realistic paragraph of text or a synthetic image).

This is where the magic lies. Discriminative AI helps machines “identify,” but Generative AI helps them “create.” Agentic AI needs both, but its ability to generate is what makes it autonomous and flexible.

🧠 Core Principle: Representation Learning

This was my favorite part of today’s learning.

Generative AI works because of representation learning — the ability of models to automatically discover useful features from raw data. Instead of us manually crafting features, the model learns what’s important.

• Encoders capture compressed, meaningful representations of input.

• Decoders reconstruct or generate output from those representations.

Transformers, autoencoders, and VAEs are all examples of this encoder-decoder magic. Representation learning is what allows GenAI to be so good at tasks like translation, summarization, and even creating original art.

🖼️ Real-World Applications That Inspired Me

By now, I was convinced of Generative AI’s potential. But what really struck me was its application power across industries:

• Computer Vision: Image synthesis, style transfer, super-resolution imaging, video synthesis, and even 3D reconstruction.

• NLP: Text generation, summarization, translation, chatbots, and storytelling.

• Data Synthesis: Generating synthetic healthcare data, balancing datasets, anonymizing private information, and even simulating driving scenarios for autonomous vehicles.

• ML Pipeline: From data preparation to deployment, GenAI is reshaping how models are trained, validated, and monitored.

• Personalization: Hyper-tailored learning paths, product recommendations, and even individualized healthcare plans.

I realized — Generative AI isn’t just an AI tool; it’s a creative partner.

⚡ The Bigger Picture – GenAI and the Gap Between Experts & Novices

One thought-provoking point was how GenAI may actually widen the gap between experts and novices. While it gives powerful tools to everyone, experts can use them with precision and domain knowledge — making them even more effective.

So while GenAI democratizes access, true expertise will always matter. This was a good reminder for me: building strong fundamentals in AI is just as important as using advanced tools.

🔮 What’s Next? (Day 5 Preview)

On Day 5, I’ll be diving deeper into the world of Large Language Models (LLMs) and their building blocks. The key topics I plan to cover include:

• Large Language Models (LLMs): Pre-read and introduction.

• Transformer Architecture: Understanding why it’s the backbone of modern AI.

• Why Transformer Models are Trending?

• GPT and Decoder-Only Models explained.

• Foundation Models: An overview of leading models shaping AI today.

• Characteristics of LLMs and what makes them powerful.

• Emergent Abilities: How new skills appear at scale.

• OpenAI Playground: Exploring and experimenting with models.

• Parameters in LLMs and their importance.

• Top-k vs. Top-p Sampling: Controlling randomness in outputs.

• Temperature and Probability Distribution: Impact on creativity and determinism.

• Microsoft Copilot: A real-world application of these concepts.

This will be a big step forward, as I begin to understand not just the theory of LLMs but also their practical applications and limitations.

Stay tuned — Day 5 is where theory meets reality 🚀.

✨ Final Thoughts

Today was less about math and more about connecting the dots. I understood not just what Generative AI is, but also why it matters and how it is accelerating the path toward Agentic AI.

It feels good to pause and reflect: Agentic AI isn’t some distant concept — it’s being built on the blocks of GenAI, representation learning, and the applications we’re already seeing around us.

👉 What do you think? Do you agree that Generative AI is the bridge from ANI to AGI? I’d love to hear your thoughts in the comments.

Stay tuned for more new projects and upcoming blogs on my GenAI learnings and experiments! 🚀

This day felt like a turning point, because attention is at the core of how today’s large language models (LLMs) work. Let me walk you through what I learned.

🔎 What is the Attention Mechanism?

The attention mechanism is a way for a model to focus on the most relevant parts of the input while processing sequences.
Instead of treating every word equally, attention allows the model to assign different weights to different words, just like how we humans focus on keywords in a sentence while skimming through text.

Why is it important?

• It helps models capture long-range dependencies (e.g., connecting “Paris” and “France” even if they are far apart in a sentence).

• It overcomes the limitations of RNNs like vanishing gradients.

• It forms the backbone of modern architectures like Transformers.

⚡ Introduction to Transformers

After attention, I learned about Transformers, a revolutionary architecture that replaced RNNs in NLP.
Transformers rely entirely on the attention mechanism instead of sequential recurrence, which makes them:

• Faster to train (parallel computation).

• More powerful in capturing long-term dependencies.

🧠 Types of Attention in Transformers

1. Self-Attention

This mechanism allows each word in a sentence to look at other words in the same sentence to understand context.
For example:
In the sentence “The dog chased its tail”, the word “its” should attend more to “dog” rather than “chased”.

Self-attention does this by creating embeddings that are weighted combinations of all words in the sentence—this is what gives Transformers their power.

2. Multi-Head Attention

Self-attention alone is powerful, but multi-head attention takes it further.

• Instead of calculating attention once, it does it multiple times in parallel (multiple “heads”).

• Each head captures different relationships (e.g., one may focus on grammar, another on semantics).

• Finally, the results are combined, making the model more robust and context-aware.

📍 Positional Embeddings

Since Transformers don’t process sequences step by step (like RNNs), they need a way to understand word order.
That’s where positional embeddings come in—they add information about the position of words in a sentence, so the model knows the difference between “dog bites man” and “man bites dog.”

📖 Embeddings from Language Models

I also explored embeddings created from language models, which capture not just word meanings but also their context.
For example, the word “bank” in “river bank” vs. “savings bank” gets different embeddings because of context.

🔄 Bidirectional Language Models

Unlike older models that read text left-to-right or right-to-left, bidirectional models (like BERT) look at the entire sentence in both directions.
This allows them to capture richer context, making them far better for understanding natural language.

🚀 ULMFiT – Transfer Learning in NLP

One of the most fascinating things I learned was ULMFiT (Universal Language Model Fine-tuning).
Here’s how it works:

1. Train a language model on a large, general dataset (like Wikipedia).

2. Fine-tune it on a smaller, task-specific dataset (like movie reviews).

3. Get much better performance with less data and training time.

This approach was a breakthrough in bringing transfer learning to NLP, just like ImageNet did for computer vision.

🛠️ Task-Specific Input Transformation

Before training, inputs often need to be reshaped or reformatted depending on the downstream task—like classification, translation, or summarization.
This ensures that the embeddings are aligned with the problem at hand.

🔡 Subword Tokenization

Finally, I learned about subword tokenization, a clever technique to handle unknown or rare words.
For example, the word “unhappiness” might be split into: “un” + “happi” + “ness”.
This helps models deal with huge vocabularies while still understanding the meaning of complex or new words.

🌟 A Sneak Peek at BERT

My journey ended today with a quick introduction to BERT (Bidirectional Encoder Representations from Transformers).
BERT uses self-attention, bidirectional context, and transfer learning to power some of the most advanced NLP applications we see today.
I can’t wait to dive deeper into it in the coming days.

✅ Key Takeaways from Day 3

• Attention mechanisms allow models to focus on relevant parts of text.

• Transformers use self-attention and multi-head attention to capture context effectively.

• Positional embeddings solve the problem of word order in Transformers.

• Bidirectional models and transfer learning (like ULMFiT) are game changers in NLP.

• Subword tokenization makes models flexible and robust for real-world language.

• BERT is the next big step I’ll be diving into.

📌 What’s Next?

On Day 4, I’ll be shifting gears a little to build a stronger conceptual foundation for my Agentic AI journey. I’ll explore:

• Why AI is so prominent today – understanding the driving factors behind its rise.

• ANI vs. AGI – differentiating between Artificial Narrow Intelligence and Artificial General Intelligence.

• AI, ML, DL, and GenAI – clarifying how these terms connect and differ.

• Discriminative vs. Generative Models – comparing how models classify vs. how they create.

• Core Principle: Representation Learning – the key idea behind how models learn meaningful patterns from data.

• Applications and Case Studies – real-world examples of how these concepts are being applied.

This will set the stage for me to not only understand how models work but also why they matter in today’s world.

Stay tuned 🚀 — Day 4 will be about bridging the gap between technical depth and real-world impact.

Day 2 was all about understanding Sequential Data and how machines process it. And trust me — this was where things started getting both tricky and fascinating!

🌱 Starting Point: What is Sequential Data?

When we deal with text, audio, or time series data, we are not just looking at individual values but at values arranged in order. This order, or sequence, actually matters. For example:

• In language, “I am learning AI” means something different from “AI learning am I.”

• In stock market data, today’s value depends on yesterday’s.

This is sequential data — data where context and order are critical.

❌ Why Not Use a Simple Neural Network?

At first, I wondered, “Why can’t we just use a regular Multilayer Perceptron (MLP)?”
But soon I realized the issue — MLPs treat every input independently. They don’t remember the previous words, sounds, or numbers. For sequences, that memory is crucial.

This is where Recurrent Neural Networks (RNNs) come into play.

🔄 Enter RNNs – The Memory of Neural Networks

RNNs were designed to handle sequential data by introducing the concept of a hidden state that carries information from the past into the future.

I visualized this through the idea of “unrolling” the RNN — each word in a sentence is passed one by one, with memory from the previous step flowing into the next.

This was a game-changer: finally, a model that could “remember.”

🔎 Digging Deeper: Types of RNNs

As I studied further, I discovered that there are variations of RNNs depending on cardinality (input-output relationships).

• One-to-One: Simple classification.

• One-to-Many: For example, image → caption generation.

• Many-to-One: Sentiment analysis from text.

• Many-to-Many: Translation or video frame prediction.

But soon, I also hit the limitations…

⚠️ The Problem: Vanishing & Exploding Gradients

While RNNs are powerful, they are not perfect. During training, as sequences get longer, they face two major issues:

• Vanishing Gradient: The network forgets distant past information.

• Exploding Gradient: Training becomes unstable.

This made me wonder — how do researchers solve this?

🧠 Smarter RNNs: LSTM & GRU

That’s when I came across LSTMs (Long Short-Term Memory) and GRUs (Gated Recurrent Units).

Both architectures use gates to decide what to keep, what to update, and what to forget. This helps them maintain long-term context in a sequence.

• LSTMs have multiple gates (input, forget, output) to carefully control information flow.

• GRUs are simpler but effective, combining some gates into fewer steps for faster training.

These models made me realize how memory management is critical in AI.

⬆️ Going Further: Stacked & Bidirectional RNNs

I also explored:

• Stacked RNNs: Multiple layers of RNNs stacked on top of each other for more complex pattern learning.

• Bidirectional RNNs: These process sequences both forward and backward, capturing context from both sides of a sentence. This was especially fascinating for language tasks.

🌍 Sequence-to-Sequence Models with Encoders & Decoders

As I progressed, I reached the encoder-decoder architecture — the backbone of machine translation.

Here’s how it works:

• The encoder reads the input sequence and compresses it into a context vector.

• The decoder takes this vector and generates the output sequence.

For example, translating “Bonjour le monde” → “Hello world.”

I also learned about how LSTMs in encoders and decoders pass information, making translation possible.

⚠️ The Shortcomings and Beam Search

Of course, this model wasn’t perfect. It sometimes lost accuracy on longer sentences. That’s where Beam Search comes in — instead of picking just the top prediction, it considers the top-N possible words at each step to improve translations.

Finally, models are evaluated using BLEU Score, which checks how close the translations are to human ones.

🎯 Wrapping Up Day 2

Day 2 was a deep dive into how machines learn from sequences. From simple RNNs to LSTMs, GRUs, and encoder-decoder models, I learned that handling order and context is what makes AI capable of language understanding and translation.

🔜 What’s Next?

For Day 3, I’ll be diving into the Attention Mechanism — a concept that revolutionized sequence models and paved the way for Transformers.

Stay tuned — the journey is just getting more exciting! 🚀

👉 What do you think I should explore along with Attention?
Drop your suggestions — I’d love to learn with your guidance!

Agentic AI is one of the most exciting, fast-evolving fields in AI today, but it can also feel overwhelming. To avoid getting lost in the hype, I decided to start with the basics — the building blocks that make Agentic AI possible.

Through my research, I realized that Generative AI is the foundation, and at the heart of Generative AI lies Natural Language Processing (NLP).

So, Day 1 of my journey was all about understanding NLP.

🔍 What I Explored on Day 1

1. What is NLP and Why Does It Matter?

I began by exploring what NLP (Natural Language Processing) is and where it is used. From auto-complete on our phones to chatbots, recommendation engines, and sentiment analysis — NLP is everywhere. Understanding this convinced me that this is the right foundation for Agentic AI.

2. Tokenization & Preprocessing

Next, I looked at how machines break down human language. Tokenization splits sentences into words, and techniques like stop word removal, stemming, and lemmatization help simplify the text while retaining meaning.

It felt like learning the grammar rules of a new language, but this time for computers.

3. Numericalizing Words

Words alone can’t be fed into a machine, so I studied how they are converted into numbers.

• One-hot encoding

• CountVectorizer

• TF-IDF vectorization

Among these, I found TF-IDF (Term Frequency–Inverse Document Frequency) more reliable because it reduces the importance of overly common words.

4. Word Embeddings

This was the most fascinating part of the day. Word embeddings transform words into vectors that capture meaning and relationships.

I explored Word2Vec, which itself has two methods:

• CBOW (Continuous Bag-of-Words) — predicts a word based on its context

• Skip-gram — predicts the context from a word

I also discovered Negative Sampling, a method that improves efficiency in training embeddings.

5. Properties of Word Embeddings

Word embeddings aren’t just numbers; they capture relationships like:

• Semantic similarity (king – man + woman = queen 👑)

• Compositionality (phrases built from word meanings)

• Compactness (smaller vector space yet meaningful)

• Context adaptation (meanings shift with context)

It amazed me how mathematics and language come together in this way.

6. The Embedding Matrix

Finally, I explored how embeddings are stored in an embedding matrix and how they can be visualized. Seeing clusters of related words together gave me a clear sense of why embeddings are such a powerful tool in AI.

🌱 Wrapping Up Day 1

Day 1 was both challenging and exciting. I started with just a curiosity about Agentic AI, but by the end of the day, I realized how much depth there is even in the “basics.”

This foundation in NLP and word embeddings will serve as the base for everything I build next in my Agentic AI journey.

🙌 Over to You

This is just the beginning. On Day 2, I’ll continue exploring deeper concepts. But I’d love to hear from you:

👉 What do you think I should learn next to strengthen my path toward Agentic AI?
Should I go deeper into embeddings, jump into Transformers, or start experimenting with hands-on Generative AI models?

I’m open to your suggestions! 🚀

It’s been a while since I last posted a blog, but I’m back — and this time with a fresh data cleaning project!

I wanted to work on something that wasn’t just a toy dataset but also gave me the chance to handle real-world messiness. So, I picked the Airbnb Open Data from Kaggle.

The goal? Take messy raw data and turn it into something consistent, clean, and ready for analysis.

When I first opened the dataset, I found:

• Unnecessary columns

• Missing values

• Inconsistent text formatting

• Duplicate rows

• Categorical values needing standardization

• Price and service fee stored as messy strings

This blog takes you through exactly what I did, step-by-step, so you can follow along.

📂 Step 1: Importing and Understanding the Data

I loaded the dataset into Pandas and did a quick scan:

import pandas as pd
df = pd.read_csv("Airbnb_Open_Data.csv")
df.head()
df.shape
df.info()
df.isnull().sum()

From this, I learned:

• 26 columns in total

• Several columns with missing values

• Some columns were clearly not useful for my analysis

🗑 Step 2: Dropping Unnecessary Columns

I removed extra fields like:

• reviews per month

• review rate number

• calculated host listings count

• availability 365

• house_rules

• license

columns_to_drop = ['reviews per month', 'review rate number',
                   'calculated host listings count', 'availability 365',
                   'house_rules', 'license']
df.drop(columns=columns_to_drop, inplace=True)

Columns before dropping unwanted columns

Columns after dropping unwanted columns

✏ Step 3: Making Column Names Consistent

To make my work easier, I converted all column names to lowercase:

df.columns = [col.lower() for col in df.columns]

🔍 Step 4: Removing Duplicate Rows

df.duplicated().sum()
df.drop_duplicates(inplace=True)

This ensured every listing was unique.

🧹 Step 5: Handling Missing Values

First, I dropped the last review column — too many missing values.
Then I removed all remaining rows with missing values:

df.drop(columns=["last review"], inplace=True)
df.dropna(inplace=True)

🔠 Step 6: Standardizing Text Data

The host_identity_verified column had mixed cases, so I converted all to uppercase:

df['host_identity_verified'] = df['host_identity_verified'].str.upper()

🔄 Step 7: Converting Boolean to Numeric

The instant_bookable column had True/False values. I converted them into 1 and 0:

df['instant_bookable'] = df['instant_bookable'].apply(lambda x: 1 if x==True else 0)

💵 Step 8: Cleaning Price and Service Fee

Both price and service fee were stored as strings with $, ,, and spaces. I removed those characters and converted them to integers:

to_remove = ['$', ',', ' ']
for char in to_remove:
    df['price'] = df['price'].str.replace(char, '')
    df['service fee'] = df['service fee'].str.replace(char, '')

df['price'] = df['price'].astype(int)
df['service fee'] = df['service fee'].astype(int)

📦 Step 9: Resetting Index and Saving

df.reset_index(drop=True, inplace=True)
df.to_csv("clean_airbnb_data.csv", index=False)

✅ Final Clean Dataset

The final dataset was:

• Free of duplicates

• Without missing values

• Clean and standardized columns

• Prices and service fees ready for numeric operations

📂 You can find my project files on GitHub: GitHub Repo Link

🔗Link to the dataset used in this project: Airbnb Open Data

📢 Stay tuned!
I’ll be sharing more new projects soon, and I’m also diving into Generative AI and projects, which I can’t wait to blog about next!

I recently downloaded a dataset from Kaggle on student performance and decided to clean it thoroughly using only code — no Excel this time! In this post, I’ll walk you through everything I did, step-by-step, including the challenges I faced and how I solved them.

Whether you're a beginner learning Pandas or someone curious about how data is cleaned before analysis or modeling, this post will give you a solid, realistic picture.

📁 Dataset Overview

The dataset I worked on contains student information — not just their test scores, but also family, education, and lifestyle-related features. Here’s what each column means:

One weird thing I spotted was an Unnamed: 0 column — probably an index from an earlier save. I dropped it immediately:

data = data.drop(columns=['Unnamed: 0'])

🛠️ Step 2: Handling Null Values

Several columns had missing values. Here’s how I tackled them:

🔹 EthnicGroup & ParentEduc

I filled their missing values using the most frequent value (mode):

data['EthnicGroup'] = data['EthnicGroup'].fillna(data['EthnicGroup'].mode()[0])
data['ParentEduc'] = data['ParentEduc'].fillna(data['ParentEduc'].mode()[0])

🔹 TestPrep, ParentMaritalStatus, PracticeSport

I looped through these related columns and applied mode-filling as well:

col_to_fill = ['TestPrep', 'ParentMaritalStatus', 'PracticeSport']
for col in col_to_fill:
    data[col] = data[col].fillna(data[col].mode()[0])

🎯 Step 3: Fixing IsFirstChild (Binary Encoding)

This column had "yes"/"no" values. I filled nulls with mode and mapped it to 1s and 0s for binary classification:

data['IsFirstChild'] = data['IsFirstChild'].fillna(data['IsFirstChild'].mode()[0])
data['IsFirstChild'] = data['IsFirstChild'].map({'yes': 1, 'no': 0})

📊 Step 4: Numerical Fixes – NrSiblings, WklyStudyHours

For NrSiblings, I filled nulls with the median and converted it to integer:

data['NrSiblings'] = data['NrSiblings'].fillna(data['NrSiblings'].median())
data['NrSiblings'] = data['NrSiblings'].astype('int64')

For WklyStudyHours, I:

• Removed spaces

• Lowercased all entries

• Mapped ranges (<5, 5-10, >10) to numerical midpoints: 2.5, 7.5, 12.5

• Filled any missing values with the median

data['WklyStudyHours'] = data['WklyStudyHours'].str.replace(" ", "").str.lower()
data['WklyStudyHours'] = data['WklyStudyHours'].map({'<5': 2.5, '5-10': 7.5, '>10': 12.5})
data['WklyStudyHours'] = data['WklyStudyHours'].fillna(data['WklyStudyHours'].median())

Column “WklyStudyHours” before mapping:

Column “WklyStudyHours” after mapping:

✂️ Step 5: Categorical Cleaning – Lowercasing & Trimming

I applied .str.strip().str.lower() on a few selected columns to clean casing and whitespace:

pythonCopyEditcol_to_clean = ['TestPrep', 'Gender', 'PracticeSport']
for col in col_to_clean:
    data[col] = data[col].str.strip().str.lower()

🔎 Step 6: Checking for Outliers in Score Columns

Before finalizing the dataset, I wanted to make sure there were no unusual or invalid scores in the three academic columns: MathScore, ReadingScore, and WritingScore.

I used the .unique() function to inspect the values in each column:

data['ReadingScore'].unique() #checking for outliers
data['MathScore'].unique()
data['WritingScore'].unique()

🧹 Step 7: Removing Duplicates

Finally, I checked for duplicate rows and dropped them if any were found:

pythonCopyEditdata.duplicated().sum()
data = data.drop_duplicates()

💾 Final Step: Exporting Cleaned Dataset

Once everything looked clean and consistent, I saved the dataset:

pythonCopyEditdata.to_csv("Cleaned student exam data.csv", index=False)

✅ Done! I now had a cleaned, structured dataset ready for EDA or modeling.

💡 What I Learned from This Project

• Real data isn’t clean — even well-structured datasets need attention.

• Pandas is powerful — chaining small functions (.map(), .fillna(), .str.strip()) creates big improvements.

• Data cleaning is decision-making — context matters when choosing between median, mode, or dropping.

🚀 What’s Next?

This was my first real experience cleaning a dataset using only code. Next, I’ll be working on:

• 🔎 Exploratory Data Analysis with Pandas and Seaborn

• 📈 Visualizations comparing scores by gender, lunch type, parental education

• 🤖 My first machine learning project: predicting test outcomes

📂 Project Files on GitHub

You can find the full project here, including:

• The Jupyter Notebook (StudentsExamScores.ipynb)

• The Raw and Cleaned CSVs

🔗 View the Project on GitHub

🙌 Let’s Connect

If you're on a similar path or want to share tips, feedback, or connect — I’d love to hear from you!

• 💻 GitHub – Projects

• 🌐 LinkedIn – Say hi

• 📝 More Blogs on Hashnode

Thanks for reading 🙏

#Pandas #Python #DataCleaning #DataScience #KaggleDataset #LearningInPublic #BeginnerProjects #JupyterNotebook #PortfolioProject

This blog is about how I worked on two datasets, faced real problems, and used basic but powerful Excel techniques to bring structure and clarity to the chaos.

📁 Dataset 1: US Presidents – Understanding the Dataset

The first dataset I tackled was about U.S. Presidents — a historic, structured list of who held office, when, and under which political party.

Here are the key columns and what they represent:

When I opened the dataset, it looked fairly clean on the surface. But as I examined it, I started spotting subtle inconsistencies:

• Some president names were in all caps, some in lowercase, and some a mix.

• Political party names had multiple spellings or formats.

• Several cells had extra white spaces.

• There was an odd column called prior which clearly didn’t belong.

🧹 How I Cleaned the US President Dataset

🔁 Step 1: Remove Duplicates

I started by checking for duplicate rows using the Remove Duplicates function from Excel's ribbon. Even a small historical dataset can have redundant entries!

🧼 Step 2: Fix the Name Formatting

Next, I applied the PROPER() function to the President column. This automatically converted entries like george washington or GEORGE WASHINGTON into the clean and proper format: George Washington.

🧠 Step 3: Standardize the Party Column

I applied filters to the Party column and found variations of the same political party, like democrat, Democratic, and even misspelled ones like Democrattic. I corrected them manually to ensure consistency.

✂️ Step 4: Clean White Spaces and Format Other Columns

To fix other formatting issues, I combined TRIM() with PROPER() in most text columns. This removed unwanted spaces and ensured each word started with a capital letter.

🗓️ Step 5: Convert Dates to Proper Format

The date updated and date created columns were formatted as text. I converted them to date format using Excel’s built-in tools for cleaner sorting and analysis.

🗑️ Step 6: Delete the Useless Column

Lastly, I deleted the priorcolumn — it had no value to the dataset.

📁 Dataset 2: Client Transactions – Understanding the Dataset

Next, I worked on a business-focused dataset that tracked client transactions. This was more practical and closer to real-world business use cases.

Here are the key columns:

🧹 How I Cleaned the Client Transactions Dataset

📐 Step 1: Resize and Explore

Before doing anything, I auto-resized all columns and rows. A clearer view helps with cleaner work.

🧾 Step 2: Clean the Client Column

The Client column had values like “XYZ Corp (inactive)”. I removed everything inside parentheses, then used the LOWER() function to standardize names in lowercase. I did this in a new column, pasted the cleaned values as values only, and replaced the original.

👤 Step 3: Clean the Contact Names

The Contact column was inconsistent too. I used TRIM() and PROPER() to clean spacing issues and convert all names to proper case (e.g., John Doe).

🏢 Step 4: Split the Department and Region

The Department_Region column combined two values, like “Finance_West”. I used Text to Columns with _ as the delimiter and split them into two new columns: Department and Region.

❌ Step 5: Remove Duplicates

I used the Remove Duplicates tool to clean any repeated rows that were sneaking in.

📭 Step 6: Fill Missing Payments

Several entries in the Payment column were blank. I selected them using “Go to Special” → “Blanks” and filled them with "NA" using Ctrl + Enter.

💡 Step 7: Fix Errors in Profit Margin

Some cells in the Profit Margin column had errors (due to zero or missing values in the formula). I used:

=IFERROR(Revenue / Profit, "NA")

to catch those and keep the sheet error-free.

🎨 Step 8: Final Touches

I formatted all headers and added some color to improve readability.

💡 What I Learned from These Projects

These may have been simple projects, but they taught me big lessons:

• Data cleaning is not glamorous, but it’s crucial. Without it, no analysis is trustworthy.

• Excel is underrated. It’s packed with powerful functions that are more than enough for beginner and intermediate cleaning tasks.

• Details matter. Whether it's a spelling mistake, a space, or a duplicate row — these small issues cause big problems later in the pipeline.

But most importantly, I learned that even basic tools can teach deep lessons about working with real data.

🚀 What’s Next?

Now that I’ve started with Excel, I’m stepping into the world of Pandas and Python. 🐍
I’ve already started a project where I’m cleaning a more complex dataset using:

• dropna(), fillna()

• Regex for text patterns

• .apply() for column transformations

• Handling missing and inconsistent values with scripts

In my next blog, I’ll walk you through that project too — and compare the experience of cleaning data in Excel vs Python.

🙌 Let’s Connect

Thanks for reading! If you’re also starting out in data science or just curious about how real-world data cleaning looks, I’d love to connect.

Follow my journey here and across platforms:

• 💻 GitHub – Code & Projects

• 🌐 LinkedIn – Let’s Connect

Let’s keep learning — and cleaning — one dataset at a time!

#Excel #DataCleaning #DataAnalytics #LearningInPublic #MSExcel #BeginnerProjects #DataScience #Python #Pandas #BloggingJourney #PortfolioProject