Final exams are done. Your buddy lives just 5 km away, and you want to gift him a copy of GTA V — all 60 GB of it.

Both of you have “awesome” 4G connections... but there’s a catch:
👉 1 GB/day data limit!

So... how on earth do you send that massive game over?
💡 Will you:

• Burn it to a USB stick and bike it over?

• Wait two months using your data plan?

• Find a clever offline or local network hack?

Let’s break it down!

The best way to send him the game is by copying the game to a Hard disk and send it, Will yo do the same thing for Sending a game like minesweeper which is in kb of size ? No because you can send it via internet. As the file size grows, time taken by online Sending increases linearly f(n’). As the file size grows, time taken by physical sending remains Constant. For example if your friend is 10 min away it will always take 10 min whether it is 5gb, 50gb or 100gb but may be more efficient in case of low end game like minesweeper which takes mins. Same goes in case of designing algorithm. If you don’t know what is algorithm, It is a process of implementing you logic in program which can differ from person to person since one problem can have multiple solution.

Why it matters?

Similar to above example, In real world, Computer’s memory usage and processor usage is precious. For this efficient data structure and algorithm has to be used. For example, You want to check whether number is prime or not for example 8 in this case. The first algo that comes in mind is dividing number from 2 to 8, if any number divides or gives remainder ‘0’ from 2 to 8 then its not prime excluding 8. You can easily implement this logic in your code but if i said you should generate best possible logic which takes minimum operation then it can hinder you sometime. This is where algorithm comes to play and every problem has it best solutions and worst too. In this case of prime number, you can divide 8 from 2 to 4, since there is no any number 8 can be divided greater than 4 except itself. You may say why it matters it only saves 4 operation but in case of ‘8164427721659987003’ it saves ‘4082213860829993501’ many operation using this logic. Similarly, there is best possible way to do it in this case nut it not the best but isn’t the worst.

Time complexity

This type of algorithm can be measured in mathematical equation. The best Algorithm is measured in worst case scenario which called time complexity and space complexity. Most people think ‘Time Complexity” is a amount of time it takes to give output given problem but it is not. The same Algorithm might perform fast depending upon system and specification. In Reality, It doesn’t measure actual seconds, but instead shows how the number of operations increases when the input gets bigger.

It is measured in mathematical equation like linear, quadratic, exponential and so on using Big O notation “O”. The diagram below contains detail explanation.

What is Big O?

👉Big O notation is a way to describe how the runtime or space used by an algorithm grows as the size of the input (usually called n) increases.

It tells us:

• The upper bound (worst-case scenario) of an algorithm’s performance.

• How the algorithm scales when the input gets really big.

Example of Big O Types

Key Idea

Big O hides constants and focuses on the part that grows fastest as n increases.
Example: 5n + 100 → Big O = O(n) (because n is the dominant term)

What Does an API Do?

An API is like a messenger.

• It sends your request to another system.

• It brings back the answer so your app can show it.

Imagine you open a food delivery app and want to see pizza shops nearby.

• Your app sends a request through an API to a server.

• The server sends back a list of shops.

• The app shows it to you.

How Does an API Work?

You (the user or app) send a request → “Give me data!”
The API takes the request → Goes to the server.
The server processes it → Finds the data.
The API returns the result → App displays it.

Common API Terms

Why do we need the API

Imagine you’re building a food delivery app.

• You want to show the user’s location on a map.

• You want to find nearby pizza shops.

• You want to draw the delivery route.

Could you build your own map system?
That would take years, cost millions, and need constant updates.

Instead, you use Google Maps API

• Your app asks Google Maps: “Where is this address?”

• Google Maps API responds with the location, shops, route, etc.

• Your app shows the map, markers, and route — easy!

This is one example of API call:

GET https://api.weather.com/v3/weather/forecast?location=Kathmandu

This is how it’s response can look which we use as how we want to use in our case:

{
  "location": "Kathmandu",
  "forecasts": [
    {
      "day": "Monday",
      "high_temp_c": 28,
      "low_temp_c": 18,
      "description": "Partly cloudy"
    }
  ]
}

Moreover, An API is secured by using API keys so only authorized apps can access it. To prevent overuse, throttling (rate limiting) controls how many requests are allowed in a time period, like 100 requests per minute. Common throttling methods include fixed window and token bucket.

This keeps the API safe, reliable, and fair.

AI APIs are cloud-based interfaces that allow us to access and use artificial intelligence models — like language, vision, or speech models — without needing to train or host them on their own servers.

Think of AI APIs as a teacher who knows it all and can reply with text, images, voice, and much more — all instantly. And the best part? We don’t need to know how they do it; we just ask and get the answer.

Where they’re used

AI APIs are everywhere! From chatbots that talk like humans, to tools that write your blogs or ads for you. They power virtual assistants, create stunning images and lifelike voices, tutor students with personalized lessons, and even help developers write and fix code — all in the blink of an eye.

Nowadays, almost every web or mobile app is evolving by integrating AI APIs to stay ahead with today’s technology. Developers use AI APIs to add smart features like chatbots that understand natural language, content generators that write automatically, image and voice creators, personalized learning assistants, and code helpers. These APIs let apps offer powerful AI capabilities without building complex models from scratch.

Types of Responses from AI APIs

1. Text Completion

This is the classic mode, where you send a prompt and get a plain text reply.

from google import genai

# Initialize Gemini model
model = genai.GenerativeModel("gemini-1.5-pro")

# Send prompt
response = model.generate_content("Write a short poem about the moon.")

# Print plain text reply
print("Plain text reply:")
print(response.text.strip())

2. Function Calling / Tool Use

Some AI APIs support structured responses where the AI can return JSON objects to trigger actions or call functions in your app.

from google import genai
import json

# Initialize Gemini model
model = genai.GenerativeModel("gemini-1.5-pro")

# Send prompt requesting structured response
response = model.generate_content(
    "Return JSON to call a function named 'add_numbers' with arguments a=5 and b=7. No explanation."
)

# Parse text as JSON
result_json = json.loads(response.text.strip())

# Print the structured result
print("Simulated function call JSON:")
print(json.dumps(result_json, indent=2))

# Example: You could then trigger your add_numbers function with this data.

3. Structured Output

You ask the model to return structured data (usually JSON) based on pattern or schema-but its just data no action

def generate_content(prompt: str):
    load_dotenv()
    api_key = os.getenv("GEMINI_API_KEY")
    client = genai.Client(api_key=api_key)
    response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=prompt,
    config={
        "response_mime_type": "application/json",
        "response_schema": CourseResponse, #Here CourseResponse pydantic model
    },)
    try:
        parsed = json.loads(response.text)
        return CourseResponse(**parsed)

Why Do Hallucinations Happen in AI APIs?

Hallucination refers to when an AI confidently produces false, misleading, or completely made-up responses. This can be a major issue in real-world applications.

Examples of Hallucination

1. Fake Citations

“According to Smith 2022 in The AI Guidebook…” (book doesn’t exist)

2. Bad Code

Returns Python code that imports a nonexistent module

3. Wrong Math

Calculates 23 × 5 = 135 (because it "sounded right")

Why Do AI Models Hallucinate?

AI models sometimes produce false or made-up information, which is known as hallucination. This happens for several reasons:

1. They predict text, not facts.
   Language models are trained to predict the next word based on patterns, not verify truth.

2. Vague or unclear prompts.
   If your input is too short or missing detail, the model fills in the blanks with guesses.

3. Outdated or limited knowledge.
   Many models don’t have real-time access to the internet, so their knowledge may be outdated.

4. No access to tools.
   Without plugins or API access, the model can't look up facts, calculate, or fetch real data.

5. High temperature settings.
   A higher temperature makes responses more creative, but also increases the chance of hallucination.

What is Temperature in AI?

Temperature is a setting that controls how creative or random the AI’s responses are.

• Low temperature (e.g., 0–0.3):
  The AI gives more focused, predictable, and accurate answers. Good for facts and code.

• High temperature (e.g., 0.7–1.0):
  The AI becomes more creative, diverse, and expressive. Good for storytelling or brainstorming — but more likely to make things up (hallucinate).

How to Handle and Reduce Hallucination

1. Write clear prompts
   Be specific. The more detail you give, the less the model needs to guess.

2. Use system messages
   Set the model’s role, like: “You are a helpful assistant. Only respond with facts.”

3. Validate responses
   Check outputs before using them — especially for structured data. Use tools like json.loads() or Pydantic.

4. Post-process results
   Add logic to catch and filter out fake data, bad links, or unsupported answers.

5. Use function calling or structured output
   Instead of asking for text, have the model return specific arguments that your system understands.

6. Lower the temperature
   Set temperature=0 for more accurate, fact-based responses.

7. Use real-time tools or APIs
   Connect the AI to your own tools, databases, or search functions to avoid guesses.

8. Have a human in the loop
   For critical use cases, let a human review the AI’s response before it’s published or used.