Forem: vaasav kumar

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.

Forem: vaasav kumar

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`