DEV Community: vaasav kumar

From LLMs to Agents: Build Smart AI Systems with Tools in LangChain

vaasav kumar — Sun, 19 Apr 2026 07:31:05 +0000

In previous blogs, we learned how to:

work with multiple LLM providers
use PromptTemplate
build a Streamlit web app

Now let’s take a big step forward.

👉 Instead of just generating text, we will build AI Agents that can use tools.

Tool → A function the AI can call
Agent → An AI system that decides which tool to use based on the question

Create a Simple Custom Tool

Let’s start with a basic example.

from langchain_core.tools import tool

@tool
def get_weather(city: str) -> dict:
    """Return weather details for a city."""
    fake_data = {
        "chennai": {"temp_c": 33, "condition": "Sunny"},
        "mumbai": {"temp_c": 31, "condition": "Humid"},
        "delhi": {"temp_c": 29, "condition": "Cloudy"},
        "bangalore": {"temp_c": 26, "condition": "Rain likely"},
    }
    return {
        "city": city,
        **fake_data.get(city.lower(), {"temp_c": 30, "condition": "Unknown"}),
    }

res = get_weather.invoke({"city": "chennai"})
print(res)

Output

{'city': 'chennai', 'temp_c': 33, 'condition': 'Sunny'}

Setup API Keys for Real Tools

For real-world tools, you’ll need API keys:

SERP_API_KEY - for web search
ALPHAVANTAGE_API_KEY - for stocks related questions
OPENWEATHER_API_KEY - for weather related questions

import os

os.environ['SERP_API_KEY'] = "aaa"
os.environ['ALPHAVANTAGE_API_KEY'] = "bbb"
os.environ['OPENWEATHER_API_KEY'] = "ccc"

Install dependencies:

pip install -U langchain-community google-search-results

Create Web Search Tool (SerpAPI)

from langchain_community.utilities import SerpAPIWrapper
from langchain_core.tools import tool
import os

@tool
def search_web(query: str) -> str:
    """Search the web for factual information."""
    serp = SerpAPIWrapper(serpapi_api_key=os.getenv("SERP_API_KEY"))
    return serp.run(query)

Create Your First Agent 🤖

from langchain.agents import create_agent

# Use your existing set_llm function
llm = set_llm('openai')

agent = create_agent(
    model=llm,
    tools=[search_web],
    system_prompt="""
    Use search_web for factual lookup

    Rules:
    - ALWAYS return output in valid JSON
    - NO explanation
    - NO extra text
    - NO markdown
    """,
)

Test the Agent 🧪

result = agent.invoke({
    "messages": [
        {"role": "user", "content": "Age of MS Dhoni and weather of his native?"}
    ]
})

print(result["messages"][-1].content)

Output

Am pasting the output which i tried in Jupyter Notebook.

Here you can see that the response output is in JSON string and not structured, so we need to add Output Format Structure to this.

Pydantic models provide the richest feature set with field validation, descriptions, and nested structures.

from langchain.agents import create_agent
from pydantic import BaseModel, Field

class SearchOutputStructure(BaseModel):
    """A query output details with structure."""
    Name: str = Field(description="Name of the Person")
    Age: int = Field(description="Age of Person")
    City: str = Field(description="Native of Person")
    Temperature: float = Field(description="Temperature of native city")

agent = create_agent(
    model=llm,
    tools=[search_web],
    response_format=SearchOutputStructure,
    system_prompt=("""
    Use search_web for factual lookup

    Rules:
    - ALWAYS return output in valid JSON
    - NO explanation
    - NO extra text
    - NO markdown

    """),
    )

# Use your existing set_llm function
llm = set_llm('openai')

result = agent.invoke({
    "messages": [
        {"role": "user", "content": "Age of MS Dhoni and weather of his native?"}
    ]
})

result["messages"][-1].content

Structured Format Output

To display Name of the queried person, add Name in SearchOutputStructure definition

Build Agent with Multiple Tools

Now let’s create a more powerful agent.

Tools Included:

🌐 Web Search
📈 Stock Price
🌦️ Weather

Define all tools

import requests
from langchain_core.tools import tool
from langchain_community.utilities import SerpAPIWrapper

@tool
def search_web(query: str) -> str:
    """Search the web for city, company and more details."""
    serp = SerpAPIWrapper(serpapi_api_key=os.getenv("SERP_API_KEY"))
    return serp.run(query)

@tool
def get_stock_price(symbol: str) -> str:
    """Get latest stock price using Alpha Vantage."""
    api_key = os.getenv("ALPHAVANTAGE_API_KEY")

    url = "https://www.alphavantage.co/query"
    params = {
        "function": "GLOBAL_QUOTE",
        "symbol": symbol,
        "apikey": api_key,
    }

    try:
        response = requests.get(url, params=params, timeout=20)
        data = response.json()

        quote = data.get("Global Quote", {})

        if not quote:
            return f"No data for symbol: {symbol}"

        price = quote.get("05. price")
        return {"price": float(price) if price else None}
    except Exception as e:
        return f"Stock API error: {e}"


@tool
def get_weather(city: str) -> str:
    """Get current weather using OpenWeather."""
    api_key = os.getenv("OPEN_WEATHER_API_KEY")

    url = "https://api.openweathermap.org/data/2.5/weather"
    params = {
        "q": city,
        "appid": api_key,
        "units": "metric",
    }

    try:
        response = requests.get(url, params=params, timeout=20)
        data = response.json()

        temp = data.get("main", {}).get("temp")
        if temp is None:
            return {"city": city, "temperature": None, "error": "Temperature not found"}

        return {"city": city, "temperature": float(temp)}
    except Exception as e:
        return {"city": city, "temperature": None, "error": str(e)}

Create Multi-Tool Agent

from pydantic import BaseModel, Field
from langchain.agents import create_agent

class SearchOutputStructure(BaseModel):
    """Structured response for person, company, stock, and weather."""
    name: str = Field(description="Name of the Person")
    companyName: str = Field(description="Currently working/owning Company")
    symbol: str = Field(description="Company Share Symbol")
    city: str = Field(description="City of the Company Headquarter")
    temperature: float | None = Field(description="Temperature in celsius of city")
    stockPrice: float | None = Field(description="Latest stockprice of company")

agent = create_agent(
    model=llm,
    tools=[search_web, get_stock_price, get_weather],
    response_format=SearchOutputStructure,
    system_prompt="""
    Use:
    - search_web to identify the person's company, stock ticker, and city
    - get_stock_price to fetch stock price
    - get_weather to fetch the city's weather

    Interpretation rules:
    - For queries like "weather in his city", first resolve the person's city.
    - Prefer the person's current work city if clearly known.
    - If that is ambiguous, use the company's headquarters city.
    - Then call get_weather with the resolved city.
    - If no city can be resolved, set city=null and weather=null.

    Return fields exactly matching the schema:
    - name
    - city
    - temperature
    - company
    - stockprice
    """
)

Test Multi-Tool Agent

result = agent.invoke({
    "messages": [
        {
            "role": "user",
            "content": "What is the share price of Tim Cook's company and weather in his company's headquarter city?"
        }
    ]
})

print(result["structured_response"])

Output

name='Tim Cook' companyName='Apple Inc.' symbol='AAPL' city='Cupertino' temperature=14.22 stockPrice=270.23

Docstring is read by the LLM to understand when and how to use the tool

What the model uses it for

deciding which tool to call

understanding what inputs mean

understanding what the tool returns

System Prompt controls how the model behaves overall instead of model guessing randomly.

One-line summary:

Docstring → helps the model choose the right tool
System prompt → helps the model use tools correctly and produce the right output

Conclusion

In this blog, we moved beyond simple LLM usage and explored how to build AI agents using tools in LangChain.

We learned how to:

create custom tools using @tool
integrate external APIs like SerpAPI, Alpha Vantage, and OpenWeather
enable LLMs to choose the right tool automatically
enforce structured outputs using system prompts

Build an AI Assistant Web App Using Streamlit

vaasav kumar — Wed, 15 Apr 2026 19:03:15 +0000

In the previous blog, we built an AI assistant using PromptTemplate and LangChain to generate:

a clinic name
possible clinic locations

In this blog, we will take the same idea and turn it into a simple web app using Streamlit.

This makes the project more practical because users can:

select a clinic type
choose a city
set a distance range
instantly generate a clinic name and suggested locations

First, install the Streamlit

pip install streamlit

Store API Keys in a Separate File

To keep the code clean, we can store API keys in a separate Python file.

Create a file named secret_keys.py

# secret_keys.py
arliai_api_key = "xxxx"
cerebras_api_key = "yyyy"
openai_api_key = "zzzz"

Create LLM Configuration File

Now create a file named llm_conf.py

This file will:

load API keys
configure providers
allow switching between LLMs easily

# llm_conf.py
import os
from secret_keys import arliai_api_key, cerebras_api_key, openai_api_key
from langchain_openai import ChatOpenAI

os.environ['ARLIAI_API_KEY'] = arliai_api_key
os.environ['CEREBRAS_API_KEY'] = cerebras_api_key
os.environ['OPENAI_API_KEY'] = openai_api_key

llm_providers = {
    "arliai": {
        "api_key": os.getenv("ARLIAI_API_KEY"),
        "base_url": "https://api.arliai.com/v1",
        "model": "GLM-4.7",
    },
    "cerebras": {
        "api_key": os.getenv("CEREBRAS_API_KEY"),
        "base_url": "https://api.cerebras.ai/v1",
        "model": "llama3.1-8b",
    },
    "openai": {
        "api_key": os.getenv("OPENAI_API_KEY"),
        "base_url": "https://api.openai.com/v1",
        "model": "gpt-4o-mini",
    }
}

def set_llm(llm_type, creative_level=0.7):
    my_provider = llm_providers[llm_type]
    llm = ChatOpenAI(
        model=my_provider["model"],
        api_key=my_provider["api_key"],
        base_url=my_provider["base_url"],
        temperature=creative_level,
    )
    return llm

This setup makes your app flexible.

You can switch providers like this:

llm = set_llm("openai")

llm = set_llm("cerebras")

Add Helper Assistant Function

Now create a file named helpers.py

This file will contain the logic to:

generate a clinic name
generate possible clinic locations
return both results together

# helpers.py
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_core.prompts import PromptTemplate

def search_location_for_clinic_with_name(llm, clinic_type, city, km):
    parser = StrOutputParser()

    name_template = PromptTemplate.from_template(
        "Opening New {clinic_type} clinic. Generate only 1 professional name for that."
        "No explanation, no numbering."
    )

    search_location_template = PromptTemplate.from_template(
        "Opening a new clinic for {new_clinic}, search 5 locations in {city} where no other opponents are found within {km} distance."
        "Return ONLY comma-separated area names. No explanation, no numbering."
    )

    name_chain = name_template | llm | parser

    full_chain = (
        RunnablePassthrough()
        | {
            "new_clinic": name_chain,
            "city": lambda x: x["city"],
            "km": lambda x: x["km"],
        }
        | {
            "clinic_name": lambda x: x["new_clinic"],
            "locations": search_location_template | llm | parser,
        }
    )

    response = full_chain.invoke({
        "clinic_type": clinic_type,
        "city": city,
        "km": km
    })

    return response

Build the Streamlit Web App

Now create the main file named clinic.py

This file will:

create the web interface
show select boxes and inputs
call the helper function
display the result

# clinic.py
import streamlit as st

from llm_conf import set_llm
from helpers import search_location_for_clinic_with_name

llm = set_llm('openai')

st.title("Generate Clinic Name & Locations")

clinic_type = st.sidebar.selectbox(
    "Pick a Type of Clinic",
    ("Ayurvedic", "Dental", "Eye", "Gynaecology", "Orthopedic", "Pediatric", "Physiotherapy", "Psychiatry", "Urology")
)

city = st.sidebar.selectbox(
    "Pick a City",
    ("Chennai", "Bangalore", "Mumbai", "Delhi", "Hyderabad", "Pune", "Madurai", "Jaipur", "Kochi", "Coimbatore")
)

km = st.sidebar.number_input(
    "Pick a Distance in KM",
    min_value=1,
    max_value=100,
    value=7
)

if clinic_type and city and km:
    response = search_location_for_clinic_with_name(llm, clinic_type, city, km)
    locations = response['locations'].strip().split(",")

    clinic_name = response['clinic_name'].strip()
    st.header(f"{clinic_type} Clinic: {clinic_name}")

    st.subheader("Generated Locations")
    for item in locations:
        st.write(f"- {item}")

Run the Streamlit App

streamlit run clinic.py

Final Thoughts

In this blog, we converted our AI helper into a Streamlit web app.

We created:

a file for API keys
a file for LLM configuration
a helper function for clinic name and location generation
a simple web app UI to run everything

This is a great starting point for building AI-powered tools with a real interface.

In the next blog, we can improve this further by adding Langchain Tools.

Build an Simple AI Assistant Using PromptTemplate & LangChain

vaasav kumar — Sun, 12 Apr 2026 17:42:09 +0000

In the previous blog, we saw how to work with multiple AI providers.

In this blog, let’s take the next step and use LangChain to build simple helper functions.

Let’s imagine this use case:

Your friend is a doctor and wants to open a new clinic. They need help with:

generating a professional clinic name
searching possible locations for the clinic

With AI, we can build a simple workflow for this.

In this blog, we will cover:

Generate a clinic name using an LLM
Generate the same using PromptTemplate
Write code to suggest locations for the clinic

Refer previous blog for selecting LLM, then follow the below steps

pip install langchain langchain-openai

1. Generate Clinic Name Using LLM

response = llm.invoke("Opening New Ayurvedic clinic. Generate only 1 professional name for that.")
response.content

Output

'Here\'s a professional name for the Ayurvedic clinic:\n\n1. **Dhara Wellness Centre**\n\nThis name is inspired by "Dhara", a Sanskrit word that means \'stream\' or \'flow\', which is often used in Ayurvedic practices to describe the continuous flow of healing energy, or \'prana\'. This name conveys the sense of a holistic and continuous approach to wellness, making it a fitting choice for an Ayurvedic clinic.'

This works, but the output is longer than expected.
We asked for only one name, but the model also returned an explanation.

That is normal with LLMs, and this is where better prompt design helps.

2. Generate Clinic Name Using `PromptTemplate`

Instead of writing the full prompt again and again, we can use PromptTemplate.

This makes the code cleaner and reusable.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import PromptTemplate

def generate_clinic_name(llm, clinic_type):
    name_template = PromptTemplate.from_template(
        "Opening New {clinic_type} clinic. Generate only 1 professional name for that."
    )
    chain = name_template | llm
    response = chain.invoke({"clinic_type": clinic_type})
    return response.content

generate_clinic_name(llm, 'ayurvedic')

This approach is better because:

the prompt becomes reusable
we can pass different clinic types
the code is cleaner and easier to maintain

For example, you can now generate names for ayurvedic clinic, dental clinic, homeopathy clinic, and more.

3A. Search Locations for a Clinic

We will ask the model to suggest clinic locations based on:

clinic type
city
distance radius

from langchain_core.runnables import RunnablePassthrough

def search_location_for_clinic(llm, clinic_type, city, km):
    name_template = PromptTemplate.from_template(
        "Opening New {clinic_type} clinic. Generate only 1 professional name for that."
    )

    search_location_template = PromptTemplate.from_template(
        "Opening a new clinic for {new_clinic}, search 5 locations in {city} where no other opponents are found within {km} distance."
        "Return ONLY comma-separated area names. No explanation, no numbering."
    )

    name_chain = name_template | llm
    full_chain = (
        RunnablePassthrough()
        | {
            "new_clinic": name_chain,
            "city": lambda x: x["city"],
            "km": lambda x: x["km"],
        }
        | search_location_template
        | llm
    )

    response = full_chain.invoke({
        "clinic_type": clinic_type,
        "city": city,
        "km": km
    })
    return response.content


location = search_location_for_clinic(llm, 'ayurvedic', 'chennai', 5)
print(location)

Output

Arumbakkam, Jafferkhanpet, Nanganallur, Pallavaram, Perumbakkam, Singaperumal Koil, Thirumazhisai, Vandalur

FYI, I have given prompt to check opponents factor also but unfortunately that doesn't seems working. May be we need to combine tools like Google Maps and Business data.

3B. Display Location with Clinic Name

Now let’s improve the result by returning both:

clinic name
suggested locations

from langchain_core.output_parsers import StrOutputParser

def search_location_for_clinic_with_name_method1(llm, clinic_type, city, km):
    parser = StrOutputParser()

    name_template = PromptTemplate.from_template(
        "Opening New {clinic_type} clinic. Generate only 1 professional name for that."
    )

    search_location_template = PromptTemplate.from_template(
        "Opening a new clinic for {new_clinic}, search 5 locations in {city} where no other opponents are found within {km} distance."
        "Return ONLY comma-separated area names. No explanation, no numbering."
    )

    name_chain = name_template | llm | parser

    full_chain = (
        RunnablePassthrough()
        | {
            "new_clinic": name_chain,
            "city": lambda x: x["city"],
            "km": lambda x: x["km"],
        }
        | {
            "clinic_name": lambda x: x["new_clinic"],
            "locations": search_location_template | llm | parser,
        }
    )

    response = full_chain.invoke({
        "clinic_type": clinic_type,
        "city": city,
        "km": km
    })
    return response

location = search_location_for_clinic_with_name_method1(llm, 'homeopathy', 'chennai', 10)
print(location)

Output

{'clinic_name': '"Nature\'s Balance Homeopathic Centre"', 'locations': 'Ambattur, Thirumullaivoyal, Vandalur, Kattankulathur, Pammal'}

3C. Beginner-Friendly Version

If you are new to LangChain, the previous chain-based approach may look advanced.

So here is a simpler version that does the same thing step by step.

def search_location_for_clinic_with_name_method2(llm, clinic_type, city, km):
    parser = StrOutputParser()

    name_template = PromptTemplate.from_template(
        "Opening New {clinic_type} clinic. Generate only 1 professional name for that."
    )

    search_location_template = PromptTemplate.from_template(
        "Opening a new clinic for {new_clinic}, search 5 locations in {city} where no other opponents are found within {km} distance. "
        "Return ONLY comma-separated area names. No explanation, no numbering."
    )

    # Step 1: Get clinic name
    name_chain = name_template | llm | parser
    clinic_name = name_chain.invoke({"clinic_type": clinic_type}).strip()

    # Step 2: Get locations
    location_chain = search_location_template | llm | parser
    locations = location_chain.invoke({
        "new_clinic": clinic_name,
        "city": city,
        "km": km
    })

    # Return both
    return {
        "clinic_name": clinic_name,
        "locations": locations
    }

location = search_location_for_clinic_with_name_method2(llm, 'ayurvedic', 'madurai', 5)
print(location)

Output

{'clinic_name': '"Sanjeevani Ayurvedic Wellness Centre" \n\nThis name combines "Sanjeevani" which is a Sanskrit word meaning "elixir of life" and "Ayurvedic Wellness Centre" to convey a holistic approach to health and wellness.', 'locations': 'Aruppukottai Road, Alagappan Nagar, Veerapandi, Pasumalai, Kattukottai.'}

For Developers

If you are learning AI, examples like this are very useful because they move beyond single prompts.

You start learning how to:

break a problem into steps
create reusable helper functions
build mini workflows using LangChain

That is where real AI development begins.

In the next blog, we’ll turn this into a real web app using Streamlit.

Stop Paying Too Much for AI: Use Multiple LLM Providers Like a Pro

vaasav kumar — Sun, 12 Apr 2026 09:32:35 +0000

If you're getting started with AI, one of the biggest challenges is cost and flexibility.

Most tutorials lock you into a single provider. But in real-world projects, you should be able to:

Switch models easily 🔄
Compare outputs ⚖️
Use free providers when possible 💸

In this blog, I’ll show a simple way to use multiple AI providers in one setup.

💡 Learn AI Without Spending Money

One of the biggest blockers for developers getting into AI is cost.

Not everyone can afford paid APIs — and that’s completely fine.

That’s why tools like:

🧠 Cerebras (free-tier models)
🔓 Open/free LLM providers
🧪 Community-hosted APIs

are game changers.

pip install openai

Generate API Keys

OpenAI → https://platform.openai.com/
Cerebras → https://cloud.cerebras.ai/
ArliAI → https://www.arliai.com/account

Beginners can use Jupyter Notebook to try the following code while others can follow in their own code editors.

🔑 Set API Keys

import os

os.environ['ARLIAI_API_KEY'] = "xxx"
os.environ['CEREBRAS_API_KEY'] = "yyy"
os.environ['OPENAI_API_KEY'] = "zzz"

⚙️ Configure Multiple LLM Providers

# Set LLM providers to change models easily
llm_providers = {
    "arliai": {
        "api_key": os.getenv("ARLIAI_API_KEY"),
        "base_url": "https://api.arliai.com/v1",
        "model": "Llama-3.3-70B-ArliAI-RPMax-v3",
    },
    "cerebras": {
        "api_key": os.getenv("CEREBRAS_API_KEY"),
        "base_url": "https://api.cerebras.ai/v1",
        "model": "llama3.1-8b",
    },
    "openai": {
        "api_key": os.getenv("OPENAI_API_KEY"),
        "base_url": "https://api.openai.com/v1",
        "model": "gpt-4o-mini",
    }
}

🧠 Helper Function to Switch Providers

from openai import OpenAI

def set_llm(provider_name):
    provider = llm_providers[provider_name]
    client = OpenAI(
        api_key=provider["api_key"],
        base_url=provider["base_url"]
    )
    return client

🧪 Test with Cerebras (Free Model)

llm = set_llm('cerebras')

name = llm.invoke("I want to open a restaurant for Indian food. Suggest a fancy name for this.")
print(name.content)

✅ Sample Output (Cerebras)

Here are some fancy name suggestions for an Indian restaurant:

1. **Maharaja's Mosaic**: This name evokes the grandeur and richness of Indian royalty, while also hinting at the diverse flavors and cuisines that Indian food has to offer.
2. **Tandoori Nights**: This name captures the essence of Indian food, with the tandoor oven being a staple of Indian cuisine. It also has a romantic and exotic connotation.
3. **Kashmiri Kitchen**: This name suggests a high-end, sophisticated dining experience, with a focus on the rich culinary traditions of the Kashmir region.
4. **Dhaba Royale**: A dhaba is a type of Indian restaurant, but by adding "Royale" to the name, you're implying a luxurious and upscale dining experience.
5. **Saffron & Spice**: Saffron is a highly prized spice in Indian cuisine, and by combining it with "Spice", you're highlighting the complex and aromatic flavors that Indian food is known for.
6. **Mumbai Magic**: This name captures the energy and vibrancy of India's largest city, while also hinting at the magic and wonder of Indian cuisine.
7. **Garam Gourmet**: "Garam" means "hot" in Hindi, and "Gourmet" implies a high-end dining experience. This name suggests a restaurant that serves spicy, flavorful food in a sophisticated setting.
8. **Rajasthani Rhapsody**: This name suggests a restaurant that serves the rich and regal cuisine of Rajasthan, with a focus on the region's unique flavors and traditions.
9. **Spice Route Bazaar**: This name captures the essence of Indian cuisine, with its complex blend of spices and flavors. The word "Bazaar" also implies a lively and vibrant atmosphere.
10. **Ayurvedic Eats**: This name suggests a restaurant that serves food that is not only delicious but also healthy and nourishing, with a focus on the principles of Ayurvedic medicine.

I hope these suggestions help inspire you to find the perfect name for your Indian restaurant!

🔁 Test the Same with OpenAI

llm = set_llm('openai')

name = llm.invoke("I want to open a restaurant for Indian food. Suggest a fancy name for this.")
print(name.content)

✅ Sample Output (OpenAI)

Here are some fancy name suggestions for your Indian restaurant:

1. **Saffron & Spice**
2. **Curry Couture**
3. **The Royal Masala**
4. **Tandoori Treasures**
5. **Noble Naan**
6. **Mystic Flavors**
7. **Bollywood Bites**
8. **Spice Symphony**
9. **Heritage Haveli**
10. **Kashmiri Delight**

Feel free to mix and match or modify any of these names to better suit your vision!

🚀 Why This Approach Matters

This is not just a simple example — it’s a real-world pattern.

With this setup, you can:

🔄 Switch between providers instantly
💸 Use free models like Cerebras
⚡ Compare outputs across models
🧪 Experiment without vendor lock-in

🧑‍💻 For Developers

Don’t just read about AI — build with it.

Start small:

Try different prompts
Compare model outputs

With the right setup, any developer can build AI-powered applications using both free and paid models.

So:

Try multiple providers
Experiment freely
Build something useful

In our next blog, we’ll build helper functions using LangChain to make this setup even more powerful.

DEV Community: vaasav kumar

From LLMs to Agents: Build Smart AI Systems with Tools in LangChain

Create a Simple Custom Tool

Output

Setup API Keys for Real Tools

Install dependencies:

Create Web Search Tool (SerpAPI)

Create Your First Agent 🤖

Test the Agent 🧪

Output

Structured Format Output

Build Agent with Multiple Tools

Define all tools

Create Multi-Tool Agent

Test Multi-Tool Agent

Output

One-line summary:

Conclusion

Build an AI Assistant Web App Using Streamlit

Store API Keys in a Separate File

Create LLM Configuration File

Add Helper Assistant Function

Build the Streamlit Web App

Run the Streamlit App

Final Thoughts

Build an Simple AI Assistant Using PromptTemplate & LangChain

1. Generate Clinic Name Using LLM

Output

2. Generate Clinic Name Using PromptTemplate

3A. Search Locations for a Clinic

Output

3B. Display Location with Clinic Name

Output

3C. Beginner-Friendly Version

Output

For Developers

Stop Paying Too Much for AI: Use Multiple LLM Providers Like a Pro

💡 Learn AI Without Spending Money

Generate API Keys

🔑 Set API Keys

⚙️ Configure Multiple LLM Providers

🧠 Helper Function to Switch Providers

🧪 Test with Cerebras (Free Model)

✅ Sample Output (Cerebras)

🔁 Test the Same with OpenAI

✅ Sample Output (OpenAI)

🚀 Why This Approach Matters

🧑‍💻 For Developers

2. Generate Clinic Name Using `PromptTemplate`