Forem: Dainwi Kumar

How I Used Ollama Locally Instead of Paying for the OpenAI API

Dainwi Kumar — Wed, 11 Mar 2026 11:04:52 +0000

Originally published on my portfolio → dainwi.vercel.app

There's a moment every indie developer dreads.

You've been building for weeks. The app is finally starting to feel real — the UI is clean, the auth works, the database is humming. And then you open the OpenAI pricing page.

That was me, sometime around midnight, staring at API costs and doing rough math in my head. InterviewAI — the AI-powered interview prep platform I was building — needed a language model at its core. It needed to generate interview questions tailored to a job role and evaluate spoken answers in real time.

The OpenAI API could do all of that beautifully. But at scale, even a modest number of daily users would rack up a bill I couldn't justify as a third-year CS student building a side project between assignments.

So I asked myself: what if I just ran the model myself?

Enter Ollama

I'd heard of Ollama before but always dismissed it as a "hobbyist" tool — something you'd use to chat with a local model for fun, not something you'd build a real feature on.

I was wrong.

Ollama lets you pull and run open-source LLMs locally with a single command. No API key. No rate limits. No usage bill. It spins up a local REST API on http://localhost:11434 that you can call from any backend.

What I Used It For

InterviewAI has one core AI-powered feature, and Ollama powers it.

Generating Interview Questions

When a user enters a job role (say, "Frontend Developer at a fintech startup"), InterviewAI generates a set of tailored interview questions — behavioural, technical, and situational.

I used gpt-oss:120b-cloud — the -cloud tag means the model doesn't run on your machine at all. Ollama automatically offloads it to their cloud infrastructure, so you skip the 65GB download and the GPU requirement entirely. But from your code's perspective, it still looks like a local call to localhost:11434 — same API, zero changes to your integration.

const response = await fetch("http://localhost:11434/api/chat", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gpt-oss:120b-cloud",
    messages: [
      {
        role: "user",
        content: `Generate 5 interview questions for a ${role} position.
                  Include 2 technical, 2 behavioural, and 1 situational question.
                  Return as a JSON array.`
      }
    ],
    stream: false
  })
});

const data = await response.json();
const questions = JSON.parse(data.response);

⚠️ Gotcha: Ollama's /api/chat returns the full response in data.response as a string. If you're expecting JSON, you need to parse it yourself — and explicitly prompt the model to return only JSON with no markdown fences. Otherwise you'll get triple-backtick JSON blocks wrapping your output and JSON.parse will throw.

The Catch: Ollama Still Needs to Be Running Locally

Here's the part nobody tells you upfront.

Even with cloud models, Ollama acts as a local proxy — your code calls localhost:11434, Ollama routes it to their cloud servers behind the scenes. That means Ollama itself still needs to be running on the machine making the call.

When I deployed InterviewAI to Vercel, the calls silently failed. Vercel serverless functions have no localhost:11434 — there's no Ollama process running there.

My solution was to keep the Ollama-powered features working in a local/self-hosted mode, while the deployed version handles it differently. For a portfolio project, this is perfectly fine — document it clearly and users who want the full AI features run it locally.

If you want cloud models to work in a fully deployed setup, Ollama offers a direct cloud API:

const response = await fetch("https://ollama.com/api/chat", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": `Bearer ${process.env.OLLAMA_API_KEY}`
  },
  body: JSON.stringify({
    model: "gpt-oss:120b",
    messages: [{ role: "user", content: prompt }],
    stream: false
  })
});

This is the production path — and it's still free-tier friendly compared to OpenAI.

Quick Setup (Try It in 2 Minutes)

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Sign in (required for cloud models)
ollama signin

# Pull the cloud model (no 65GB download)
ollama pull gpt-oss:120b-cloud

# Test it
curl http://localhost:11434/api/chat -d '{
  "model": "gpt-oss:120b-cloud",
  "messages": [{"role": "user", "content": "What is a closure in JavaScript?"}],
  "stream": false
}'

That's it. Your local GPT is running.

Was It Worth It?

Completely.

For a project where I needed to move fast, experiment freely, and not worry about burning through API credits every time I tested a new prompt — running Ollama locally was the right call. I iterated on prompts dozens of times without a second thought about cost.

gpt-oss isn't a compromise. For structured tasks — generating questions from a template, scoring an answer against a rubric — it's genuinely good enough. And "good enough" that's free beats "perfect" that costs money you don't have.

If you're a student or indie dev building something AI-powered, give Ollama a real shot before reaching for the OpenAI dashboard. You might be surprised how far it gets you.

About Me & What I'm Building

I'm Dainwi, a third-year CS student at Galgotias University building full-stack and mobile apps.

Here's what I'm currently working on:

🎙️ InterviewAI — AI-powered interview prep (Next.js, Cloudflare D1, Ollama)
📝 Opus — A Flutter task manager with offline-first sync (like Things 3 for Android)
🌐 Portfolio — All my projects, blog posts, and experience

If this helped you, check out my other posts and projects at dainwi.vercel.app — I write about real problems I hit while building, not theory.

And if you're into dev content in Hinglish, follow me on Instagram @iamdainwichoudhary 🇮🇳

Have you tried Ollama? Drop your experience in the comments — I'm curious what models others are using for production-ish projects.

Beyond "Hello, World": 5 Unconventional Programming Projects to Level Up Your Skills

Dainwi Kumar — Sat, 26 Apr 2025 09:48:01 +0000

Software development is about solving problems, not just mastering syntax. While tutorials and coding challenges have their place, there's nothing quite like building something unique to truly level up your skills. In this post, I'll share five unconventional project ideas that will push your programming abilities in new directions while creating something genuinely useful or interesting.

1. Build a Personal Knowledge Management System

Most developers accumulate vast amounts of knowledge throughout their careers—code snippets, solutions to tricky problems, useful articles, and technical notes. Rather than relying on bookmarks or scattered notes, why not create your own knowledge management system?

A personal knowledge management system goes beyond simple note-taking. You could implement:

Full-text search across all your notes and code snippets
Automatic tagging and categorization using NLP
Spaced repetition for learning difficult concepts
Bi-directional linking between related notes
Version history for your knowledge base

This project touches on databases, search algorithms, potentially machine learning, and UI design—all while creating something you'll actually use daily.

2. Create a Programmable Home Dashboard

Smart homes are becoming increasingly common, but most solutions are siloed within specific ecosystems. Create a unified dashboard that brings together information from various sources:

Weather forecasts aligned with your calendar events
Public transit delays that might affect your commute
Home energy usage patterns
Package delivery notifications
Custom automations based on your specific needs

The technical challenges include working with various APIs, implementing real-time updates, creating an intuitive interface, and possibly extending the system to work with IoT devices.

3. Develop a Personal Finance Analyzer

Financial applications abound, but most focus on tracking rather than analysis. Build a system that helps you understand your financial patterns:

Automatically categorize and tag transactions
Identify recurring expenses and subscription creep
Forecast future spending based on historical patterns
Create "what-if" scenarios for major financial decisions
Visualize spending relative to income over time

This project will deepen your understanding of data processing, statistical analysis, and visualization techniques. Plus, it might just help you save money!

4. Build a Custom Static Site Generator

While there are plenty of static site generators available, creating your own offers unique insights into content management, build systems, and templating engines. Your generator could include:

Custom markdown extensions for your specific needs
Automatic image optimization and responsive handling
Built-in SEO optimization
Performance metrics tracking
Integrations with your preferred deployment platforms

By building this tool, you'll learn about parsing, template rendering, asset pipelines, and performance optimization techniques.

5. Create a Collaborative Code Playground

Online code playgrounds are invaluable for teaching and sharing code examples. Building your own collaborative playground could include:

Real-time code sharing and collaboration
Support for multiple programming languages
Interactive visualization of code execution
Built-in linting and formatting
The ability to save and share "fiddles"

This project explores real-time web technologies, compiler/interpreter integration, and collaborative editing algorithms.

Why These Projects Matter

These projects stand out because they:

Solve real problems you might personally have
Combine multiple domains of knowledge
Involve systems thinking rather than just feature implementation
Can start simple and grow in complexity as your skills develop
Result in portfolio pieces that demonstrate your problem-solving abilities

Getting Started

Choose a project that aligns with both your interests and your growth areas. Start with a minimal viable implementation and expand from there. Document your journey—the challenges, decisions, and lessons learned make for excellent content to share with the community.

Remember that the goal isn't perfection but learning. These projects may never be "finished" in the traditional sense, as they can continue evolving alongside your skills.

What unconventional project are you working on to level up your development skills? Share in the comments below!

Understanding Prim's Algorithm for Minimum Spanning Trees

Dainwi Kumar — Tue, 22 Apr 2025 11:05:24 +0000

Prim's algorithm is a fundamental greedy algorithm in graph theory that helps us find the minimum spanning tree (MST) of a connected weighted graph. In this post, I'll break down how Prim's algorithm works and walk through a C++ implementation that efficiently solves this classic problem.

What is a Minimum Spanning Tree?

Before diving into the algorithm, let's clarify what we're trying to achieve. A spanning tree of a graph is a tree that includes all vertices of the graph with the minimum possible number of edges. When our graph has weighted edges, a minimum spanning tree is a spanning tree where the total weight of all edges is minimized.

Minimum spanning trees have numerous real-world applications:

Network design (telecommunications, electrical grids)
Cluster analysis
Circuit design
Transportation planning
Approximation algorithms for NP-hard problems like the Traveling Salesman Problem

How Prim's Algorithm Works

Prim's algorithm builds the MST one vertex at a time, starting from an arbitrary vertex and growing the tree by adding the lowest-weight edge connecting the tree to a vertex not yet in the tree. Here's the basic approach:

Start with any vertex as a single-vertex tree
Grow the tree by adding the minimum-weight edge that connects the tree to a vertex not yet in the tree
Repeat step 2 until all vertices are included in the tree

The C++ Implementation

Let's analyze the C++ code that implements Prim's algorithm:

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

// Function to find the minimum spanning tree using Prim's algorithm
int primMST(vector<vector<int>> &graph, int V)
{
    // Create a priority queue to store the edges
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

    // Create a vector to store the minimum weight of each vertex
    vector<int> key(V, INT_MAX);

    // Create a vector to store the parent of each vertex in the MST
    vector<int> parent(V, -1);

    // Create a vector to track if a vertex is included in the MST
    vector<bool> inMST(V, false);

    // Set the key of the first vertex to 0
    key[0] = 0;

    // Add the first vertex to the priority queue
    pq.push({0, 0});

    // Loop until the priority queue is empty
    while (!pq.empty())
    {
        // Extract the vertex with the minimum key from the priority queue
        int u = pq.top().second;
        pq.pop();

        // Mark the vertex as included in the MST
        inMST[u] = true;

        // Loop through all the vertices
        for (int v = 0; v < V; v++)
        {
            // If the vertex is not included in the MST and there is an edge between u and v
            if (!inMST[v] && graph[u][v] != 0)
            {
                // If the weight of the edge is smaller than the current key of v
                if (graph[u][v] < key[v])
                {
                    // Update the key of v
                    key[v] = graph[u][v];

                    // Update the parent of v
                    parent[v] = u;

                    // Add v to the priority queue
                    pq.push({key[v], v});
                }
            }
        }
    }

    // Calculate the total weight of the MST
    int totalWeight = 0;
    for (int i = 1; i < V; i++)
    {
        totalWeight += graph[i][parent[i]];
    }

    return totalWeight;
}

int main()
{
    // Number of vertices
    int V = 5;

    // Adjacency matrix representation of the graph
    vector<vector<int>> graph = {
        {0, 2, 0, 6, 0},
        {2, 0, 3, 8, 5},
        {0, 3, 0, 0, 7},
        {6, 8, 0, 0, 9},
        {0, 5, 7, 9, 0}};

    // Find the minimum spanning tree
    int totalWeight = primMST(graph, V);

    // Print the total weight of the MST
    cout << "Total weight of the minimum spanning tree: " << totalWeight << endl;

    return 0;
}

Key Components of the Implementation

Data Structures

Priority Queue: We use a min-priority queue to always select the edge with the minimum weight. The queue stores pairs of {weight, vertex}.
Key Vector: Stores the minimum weight of the edge that connects each vertex to the MST being constructed.
Parent Vector: Tracks the parent of each vertex in the MST, allowing us to reconstruct the tree if needed.
inMST Vector: Keeps track of which vertices have already been included in the MST.

Time Complexity Analysis

The main loop runs V times (once for each vertex)
For each vertex, we may add at most V-1 entries to the priority queue
Each extract-min operation takes O(log E) time
Overall time complexity: O(E log V), where E is the number of edges and V is the number of vertices

When using an adjacency matrix as in our implementation (which has V² potential edges), the time complexity becomes O(V² log V).

Visualizing the Process

Let's see how the algorithm works on our example graph with 5 vertices:

We start at vertex 0
We examine all edges from vertex 0: (0,1) with weight 2 and (0,3) with weight 6
We select the edge with minimum weight: (0,1) with weight 2
From the vertices now in our tree (0 and 1), we look at all edges to vertices not yet in the tree
We continue this process until all vertices are included

The final MST has a total weight of 16, which consists of the edges:

(0,1) with weight 2
(1,2) with weight 3
(1,4) with weight 5
(0,3) with weight 6

Advantages of Prim's Algorithm

Simplicity: The algorithm is conceptually straightforward
Efficiency: Works well for dense graphs
Guaranteed optimality: Always finds the minimum spanning tree

When to Use Prim's vs. Kruskal's

Prim's algorithm is one of two popular algorithms for finding MSTs, the other being Kruskal's algorithm. While both produce the same result, they differ in approach:

Prim's grows a single tree from a starting vertex
Kruskal's builds a forest of trees that eventually merge into a single MST

Prim's algorithm tends to perform better on dense graphs, while Kruskal's may be faster on sparse graphs.

Conclusion

Prim's algorithm is an elegant and efficient solution for finding minimum spanning trees. The implementation we explored uses a priority queue to optimize the selection of the next edge, making it suitable for practical applications on large graphs.

By understanding this algorithm, you gain insight into an important technique in graph theory that has numerous real-world applications. Whether you're designing networks, analyzing data clusters, or solving complex optimization problems, Prim's algorithm is a valuable tool in your algorithmic toolkit.

If you found this helpful, feel free to share your thoughts in the comments! What other graph algorithms would you like to explore next?

The Rise of AI Agents: Transforming How We Work and Live

Dainwi Kumar — Thu, 03 Apr 2025 16:20:20 +0000

The Rise of AI Agents: Transforming How We Work and Live

Hey there! I've been thinking a lot about AI agents lately, and I wanted to share some thoughts about how these fascinating technologies are changing the game for all of us.

What Are AI Agents?

So what exactly are AI agents? Think of them as digital assistants on steroids. Unlike the basic AI tools that just respond when you poke them, agents can actually take the initiative, make decisions on their own, and handle complex tasks without you having to micromanage every step. Pretty cool, right?

I was talking to a friend in tech recently who described it perfectly: "It's like the difference between having someone answer your questions versus having someone actually solve your problems." That really hit home for me.

The Variety of AI Agents

All kinds of AI agents are popping up these days. Some are laser-focused on specific tasks (like scheduling your meetings or handling customer service questions), while others are more versatile personal assistants who learn your preferences over time. The coding ones fascinate me – they can write, debug, and even optimize software, which is mind-blowing if you think about it.

Real-World Impact

Just last week, I was struggling with a repetitive data entry task that would have taken hours. I decided to try an AI agent that could interact with my spreadsheets, and it knocked out the entire project while I grabbed lunch. That kind of experience really makes you rethink how we work.

The Technology Behind AI Agents

Behind the scenes, these agents combine several powerful technologies. They're built on large language models (like the tech powering ChatGPT), but they also use special planning algorithms to break down complex tasks and memory systems that help them maintain context about what they're doing.

Challenges and Limitations

Of course, it's not all sunshine and rainbows. AI agents still struggle with reliability sometimes – I've definitely had moments where I've given an agent a task only to find it went completely off the rails! And there are important questions about trust, safety, and making sure humans maintain appropriate control.

The Future of AI Agents

Looking ahead, I'm particularly excited about multi-agent systems, where specialized agents work together like a team. Imagine having one agent research a topic, another draft content based on that research, and a third polish and refine the final product – all working in harmony.

Conclusion

At the end of the day, I think AI agents are changing our relationship with technology in a fundamental way. They're evolving from tools we actively operate to partners we collaborate with. And while there are still plenty of kinks to work out, the potential to free us from routine tasks and let us focus on more creative, meaningful work is incredibly promising.

What do you think? Have you tried working with any AI agents yet? I'd love to hear about your experiences!

AI Revolutionizing tech and society through innovation and ethics.

Dainwi Kumar — Fri, 12 Jul 2024 02:21:47 +0000

Introduction to Artificial Intelligence

Artificial Intelligence (AI) has become an integral part of our lives, shaping the way we interact with technology and paving the path for a more advanced future. From voice assistants to self-driving cars, AI has made significant advancements in various industries, showcasing its potential to revolutionize the world as we know it.

Types of Artificial Intelligence

Narrow AI: Designed for specific tasks like facial recognition or language translation.
General AI: Exhibits human-like intelligence and can perform various intellectual tasks.
Strong AI: Hypothetical form surpassing human intelligence, potentially outperforming humans in all cognitive tasks.

Applications of AI in Various Industries

AI has found widespread applications across different sectors, transforming operations and enhancing efficiency:

Healthcare: AI-powered diagnostics improve patient outcomes.
Finance: AI algorithms analyze market trends and optimize investment strategies.
Manufacturing: Robotics and automation enhance production processes.

Machine Learning and Deep Learning

Machine Learning: Enables machines to learn from data and make predictions.
Deep Learning: Advanced machine learning using neural networks to process vast amounts of data.

Natural Language Processing (NLP)

Facilitates seamless communication between humans and machines through applications like chatbots and language translation.

Computer Vision

Allows machines to interpret and analyze visual information, used in facial recognition and autonomous vehicles.

Robotics and Automation

Revolutionizing manufacturing by streamlining processes and enhancing precision.

Ethical Concerns in AI

Privacy, bias, and accountability considerations are crucial in AI development.

Future of Artificial Intelligence

Ongoing research and development are pushing the boundaries of AI innovation:

AI Ethics: Ensuring transparency and fairness in AI algorithms.
Autonomous Systems: Shaping a future where AI plays a central role in societal progress.

Impact of AI on Jobs

While enhancing efficiency, AI raises concerns about job displacement and the need for upskilling.

AI in Education

Personalizes learning experiences and provides interactive tools for students and educators.

AI in the Entertainment Industry

Leverages AI for content recommendations and personalized entertainment experiences.

Challenges in the Adoption of AI

Addressing challenges related to data privacy, regulatory compliance, and cultural barriers.

The Role of AI in Climate Change

Optimizes energy consumption and monitors environmental changes for sustainable practices.

Conclusion

Artificial Intelligence is reshaping the future landscape of technology and innovation. By harnessing its power responsibly and ethically, we can create a more intelligent and sustainable world.

JavaScript Normal Functions vs Arrow Functions

Dainwi Kumar — Sun, 07 Apr 2024 04:01:30 +0000

Are you curious about the difference between normal functions and arrow functions in JavaScript? Let's explore this concept in simple terms!

In JavaScript, functions are blocks of code designed to perform a particular task. There are two main types: normal functions and arrow functions.

Normal functions:

function greet(name) {
  return "Hello, " + name + "!";
}

Normal functions are defined using the function keyword followed by the function name and parameters. They have their own this value which is determined by how they are called.

Arrow functions:

const greet = (name) => {
  return "Hello, " + name + "!";
};

Arrow functions are a more concise way to write functions introduced in ES6. They use the arrow => to separate the parameters from the function body. Unlike normal functions, arrow functions do not have their own this value. Instead, they inherit the this value from the enclosing lexical context.

Let's see the difference in usage:

Normal function:

const person = {
  name: "Alice",
  greet: function() {
    return "Hello, " + this.name + "!";
  }
};

Arrow function:

const person = {
  name: "Alice",
  greet: () => {
    return "Hello, " + this.name + "!";
  }
};

In the normal function example, this.name refers to the name property of the person object. However, in the arrow function example, this.name will be undefined because arrow functions do not have their own this binding.

In summary, normal functions and arrow functions have similar functionalities, but differ in syntax and behavior, particularly with regards to the this keyword. Understanding these differences can help you choose the right type of function for your JavaScript code!

And that's it! You've just learned about the difference between normal functions and arrow functions in JavaScript. Happy coding! 🚀

Easy JavaScript with Arrow Functions!

Dainwi Kumar — Sat, 06 Apr 2024 18:01:55 +0000

Do you want to make your JavaScript code more concise? Look no further than arrow functions! Arrow functions are a modern feature in JavaScript that allows you to write functions in a simpler and more streamlined way. Let's dive in and see how they work.

An arrow function looks like this:

const add = (a, b) => {
  return a + b;
};

In this example, addis a function that takes two parameters, a and b, and returns their sum. The => symbol is what makes this an arrow function. It's like saying "take these parameters and do this operation".

Arrow functions are especially useful for shortening code when passing functions as arguments to other functions. For example, suppose you have an array of numbers and you want to double each number. You could use the map function along with an arrow function like this:

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(num => num * 2);

In this code, map takes each element of the numbers array and applies the arrow function to it, doubling each number. The result is stored in the doubled array.

Another benefit of arrow functions is that they have a shorter syntax for certain cases. If the function body consists of only a single expression, you can omit the curly braces and the return keyword. For example, the add function from earlier can be written even more concisely like this:

const add = (a, b) => a + b;

This is particularly handy when writing small, simple functions.

So there you have it! Arrow functions are a powerful tool in modern JavaScript for writing cleaner, more readable code. Give them a try in your next project and see how they can simplify your code!