Forem: Aakash Aggarwal

How to Prevent Hallucinations When Integrating AI Into Your Applications

Aakash Aggarwal — Wed, 16 Apr 2025 19:03:33 +0000

AI has made its way into production applications across industries—from search assistants to medical diagnosis, and even legal document summarisation. But one persistent problem can tank user trust and business credibility: AI hallucinations.

In this post, we’ll break down what hallucinations are, why they happen, and how you can actively prevent them when integrating large language models (LLMs) into your app.

What Are AI Hallucinations?

AI hallucinations occur when an LLM generates output that sounds confident and fluent, but is factually inaccurate, made-up, or misleading.

Example:

“Albert Einstein was born in 1975 in Canada.”

Confidently wrong.

For mission-critical apps (healthcare, fintech, legal tech), hallucinations can be dangerous. So, how do we deal with this?

Why Do LLMs Hallucinate?

They don’t “know” facts—they predict the most likely next word.
They are trained on incomplete, biased, or outdated data.
They fill in gaps even when unsure, rather than returning “I don’t know.”

Strategies to Prevent or Reduce Hallucinations

Here’s a practical guide to mitigating hallucinations in your AI-powered features.

1. Ground the Model with RAG (Retrieval-Augmented Generation)

Instead of asking the LLM to generate answers from its pre-trained knowledge, provide it with contextual documents from your own data.

How it works:

You embed your internal documents (PDFs, KBs, FAQs, etc.)
On user query, retrieve relevant docs → pass them to the LLM
The model generates responses only based on what’s retrieved

Tools: LangChain, LlamaIndex, Haystack

2. Always Cite Sources

Instruct the model to include citations for its answers. This:

Encourages the model to stay close to the source
Makes it easier to verify output
Builds user trust

Example prompt:

“Answer using only the provided context. Cite the source file name for each answer.”

3. Use Function Calling / Tool Use

LLMs are great at orchestrating—but not always accurate. Let them call APIs, fetch data from a database, or do calculations via plugins instead of guessing.

Example:

❌ "What's 17% of ₹3,49,000?" → Hallucinated answer

✅ Let it call a math API

4. Implement Output Validation Layers

Don't just trust the output blindly. Run it through:

Regex or Schema validation (for expected formats)
Fact-checking submodels or external verification tools
Human-in-the-loop review for high-stakes decisions

5. Use Temperature and Top-p Tuning

Lower the temperature to make responses less creative and more deterministic. For factual tasks, this helps reduce the chances of hallucination.


python
response = openai.ChatCompletion.create(
  model="gpt-4",
  messages=your_messages,
  temperature=0.2,
)


Bonus: Tell It What NOT to Do

Instructional prompting helps a lot:

“If you are unsure or don’t find the answer in the context, say: ‘I don’t know based on the given data.’”

Models often follow that instruction well. Try combining this with RAG for best results.

Hallucinations won’t go away completely, but you can control and contain them.

What is Rate Limiting and How to Add It in Django

Aakash Aggarwal — Fri, 11 Apr 2025 12:06:12 +0000

Have you ever seen an error like “429 Too Many Requests”? That’s because of rate limiting. In this post, we’ll learn:

What is rate limiting
Why it’s important
How to add rate limiting in a Django project (with simple steps)

What is Rate Limiting?

Rate limiting means putting a limit on how many times someone can call your API or access a resource in a specific time.

Example:

“You can only make 5 requests per minute.”

It helps keep your website or API safe and fair for everyone.

Why is Rate Limiting Important?

Stop Abuse

Stops bots or attackers from spamming your website.

Save Server Resources

Avoids server overload and crashes.

Fair Usage

Makes sure no one uses more than their share.

Better Performance

Keeps your app fast and smooth.

How to Implement Rate Limiting in Django

We can use a third-party package called django-ratelimit

Step 1: Install the Package

pip install django-ratelimit

Step 2: Add to Your Django View

from django.http import JsonResponse
from ratelimit.decorators import ratelimit

@ratelimit(key='ip', rate='5/m', block=True)
def my_api_view(request):
    return JsonResponse({"message": "This is a rate-limited API!"})

What this does:

key='ip' → limit by user’s IP address
rate='5/m' → max 5 requests per minute
block=True → block extra requests with 429 error

Now, Try hitting the API more than 5 times per minute from the same IP.

You will get

{
  "detail": "Request was throttled. Expected available in 60 seconds."
}

Rate limiting is simple but powerful. It keeps your API healthy and safe.

Let me know if you tried this in your Django project or if you want help with a specific use case!

How to Integrate AI into Your Web App in 2025 (Without Losing Your Mind)

Aakash Aggarwal — Thu, 10 Apr 2025 17:31:53 +0000

AI is everywhere in 2025 — chatbots, smart replies, content generators. But did you know it’s actually super easy to add AI to your own web app?

In this post, I’ll show you how to use OpenAI’s GPT model in a web app to summarize text — like blog posts, notes, or articles. No need to be an AI expert. Just some basic web dev skills and an API key!

What We’re Building

A simple app where users can:

Paste some text
Click a button
Get a smart summary from AI

What You’ll Need
• Python (we’ll use Flask for the backend)
• OpenAI API key (you can get it from platform.openai.com)

# app.py
from flask import Flask, request, jsonify
import openai
import os

app = Flask(__name__)
openai.api_key = os.getenv("OPENAI_API_KEY")

@app.route('/summarize', methods=['POST'])
def summarize():
    data = request.get_json()
    text = data.get("text", "")

    if not text:
        return jsonify({"error": "No text provided"}), 400

    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a helpful assistant that summarizes text."},
            {"role": "user", "content": text}
        ]
    )
    summary = response['choices'][0]['message']['content']
    return jsonify({"summary": summary})

if __name__ == '__main__':
    app.run(debug=True)

Make sure to set your OpenAI key:

export OPENAI_API_KEY=your_key_here

That’s It!

You now have a basic web app that uses AI to summarize text.