DEV Community: Arun Sai Veerisetty

Goodbye REST? Build a Modern GraphQL Todo API with Python + FastAPI 🍓

Arun Sai Veerisetty — Tue, 03 Jun 2025 21:24:04 +0000

Have you ever felt frustrated managing multiple REST endpoints, chasing over-fetching or under-fetching data? Enter GraphQL — a modern alternative to REST APIs that lets clients request exactly what they need.

In this tutorial, you’ll build a simple but powerful Todo API using Python, leveraging:
• ⚡ FastAPI — a blazing fast, modern web framework
• 🍓 Strawberry — a Python-native GraphQL library with type hints
• 💾 SQLite + SQLModel — lightweight and easy data persistence
• 🐳 Docker — containerize your app for easy deployment
• 🌐 Render — deploy your app in minutes for free

By the end, you’ll have a fully working GraphQL API deployed on the cloud — and all the code will be on GitHub for you to explore and extend.

💻 Code: https://github.com/arunsaiv/graphql-todo-api

Why Choose GraphQL Over REST?

REST APIs are great, but as apps grow, you often face challenges:
• Multiple endpoints for related data
• Over-fetching or under-fetching data
• Versioning headaches

GraphQL solves these by letting clients ask for exactly the data they want in a single request, reducing network overhead and improving developer experience.

What You’ll Build

A Todo API that supports:

• Adding todos
• Marking them completed
• Deleting todos
• Querying all or filtered todos

All via a clean GraphQL schema, with a built-in playground UI to try queries live.

Setting Up the Project

Create a new folder and initialize the project

mkdir graphql-todo-api
cd graphql-todo-api
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

Create a requirements.txt file with these dependencies:

fastapi
strawberry-graphql[fastapi]
uvicorn
sqlmodel

Install the dependencies

pip install -r requirements.txt

Understanding GraphQL: The Basics

GraphQL is a query language for APIs developed by Facebook to make data fetching more efficient and flexible than traditional REST APIs.

How GraphQL Differs from REST

• Single Endpoint: Unlike REST which uses multiple endpoints (e.g., /todos, /users), GraphQL uses a single endpoint (like /graphql) to handle all requests.
• Client-Driven Queries: Clients specify exactly what data they want — no more, no less. This prevents over-fetching or under-fetching.
• Strongly Typed Schema: GraphQL APIs expose a schema that defines the types of data and operations (queries and mutations) available.
• Real-time Data: Supports subscriptions for real-time updates (though not covered here).

Key Concepts

Term: What It Means
Query: A read-only fetch operation
Mutation: A write operation (create, update, delete)
Schema: The structure defining data types & operations
Resolver: Function that fetches or modifies data for a field

🧱 Tech Stack: What We Used and Why

Let’s break down each tech choice and why it made sense for this project:

🐍 Python

The language of choice for rapid backend development. Python’s clean syntax and huge ecosystem made building and testing fast.

⚡ FastAPI

A modern web framework built for speed and type safety. We chose FastAPI because:
• It uses Python type hints for automatic validation and docs
• It plays well with async and GraphQL
• It’s fast enough for production workloads

🍓 Strawberry GraphQL

A Pythonic GraphQL library that feels natural for developers. We chose Strawberry because:
• It lets you define GraphQL schemas using plain Python classes
• It supports modern typing and IDE autocompletion
• It integrates smoothly with FastAPI

💾 SQLite + SQLModel

SQLite is lightweight and file-based — ideal for demo and local development.

SQLModel (by the creator of FastAPI) combines Pydantic and SQLAlchemy to:
• Define data models with type hints
• Automatically create and query the SQLite database
• Keep everything concise and maintainable

🐳 Docker

Docker helps package the app with all dependencies so it runs identically everywhere.

We used it to:
• Create a container that holds Python, the app, and its dependencies
• Avoid “it works on my machine” bugs
• Simplify deployment to Render

🌐 Render

Render is a developer-friendly cloud platform with a free tier. It:
• Connects to GitHub
• Deploys Docker containers automatically
• Provides a public URL out of the box

✨ Try It Live

No setup needed — you can try the GraphQL API right now:
👉 https://graphql-todo-api.onrender.com/graphql

Use the playground to:
• Add a todo
• Mark it completed
• Delete it
• Filter by status

Note: The app would take upto one minute to load if the application is set to idle for more than 15 minutes, since, it is hosted for feee and Render would free up the space for utilisation.

🧭 What’s Next?

Some ideas to extend this project:
• Add a React UI with Apollo Client
• Migrate to PostgreSQL for production
• Add JWT authentication
• Use GraphQL subscriptions for real-time updates

💬 Final Thoughts

This project shows how smooth and elegant building a GraphQL API in Python can be — no REST clutter, no boilerplate, and fully typed.

If you’re curious about GraphQL or tired of juggling REST endpoints, this stack is worth exploring.

🙌 Like What You Read?

If this helped you:

💬 Leave a comment
🔁 Share it with your network
🌟 Star the GitHub repo!

Let's connect on LinkedIn!

# How to Throttle Like a Pro: 5 Rate Limiting Patterns in Python You Should Know 🚦🐍

Arun Sai Veerisetty — Mon, 02 Jun 2025 21:42:18 +0000

In today’s world of high-scale APIs, bots, and distributed systems, rate limiting is not just a nice-to-have—it’s essential. Whether you're protecting your server from abuse or controlling how often a user can take action, rate limiting is the key to reliability and fairness.

In this blog, we’ll explore 5 powerful rate limiting patterns with hands-on Python implementations. By the end, you’ll not only understand when and why to use each pattern but also walk away with real code to apply in your own projects.

🧠 What is Rate Limiting?

Rate limiting is the process of restricting how many requests or actions a system allows over a period of time. For example, “No more than 5 login attempts per minute” or “Only 100 API calls per hour”.

This is crucial for:

Avoiding abuse or spam.
Managing traffic spikes.
Fair resource usage.
Avoiding overloads and DDoS attacks.

🧩 Overview of Patterns

Here’s a quick glance at the patterns we'll cover:

Pattern	Allows Bursts?	Description	Best For
Fixed Window	❌	Simple time window	Basic rate limiting
Sliding Window	❌	Fairer than fixed window	API fairness
Leaky Bucket	✅ (Smooth)	Queues excess traffic	Traffic shaping
Token Bucket	✅	Token-based burst tolerance	Most flexible rate limits
Distributed (Redis)	✅	Multi-server rate limiting	Scalable systems

1. 🪟 Fixed Window

Concept: Allow N actions per fixed time window (e.g., per minute).

Analogy: Like a parking garage that resets at midnight — doesn’t matter when you arrived, just how many came during the time.

Pros: Simple to implement.

Cons: Susceptible to bursts at window edges.

2. 🪟 Sliding Window

Concept: Records timestamps of requests and checks the rolling window.

Analogy: Like keeping a log of visitors for the last 60 seconds — fair and accurate.

Pros: Fairer than fixed window.

Cons: Slightly more complex.

3. 🪣 Leaky Bucket

Concept: Adds requests to a queue, and processes them at a fixed rate.

Analogy: Like a faucet dripping water at a steady rate, even if you pour a bucket into it.

Pros: Smoothens traffic.

Cons: Can introduce latency.

4. 🎟️ Token Bucket

Concept: Tokens are added at a fixed rate; each request consumes a token.

Analogy: Like a vending machine that refills slowly — if you have tokens, you can burst; otherwise, wait.

Pros: Flexible and burst-tolerant.

Cons: Requires token logic and state.

5. 🌐 Distributed Rate Limiting (with Redis)

Concept: Use a shared data store like Redis to manage limits across servers.

Analogy: Like a shared notebook in the cloud tracking user activity.

Pros: Scalable, central tracking.

Cons: Needs external Redis setup.

🛠️ Make sure Redis is running locally or remotely before testing.

💻 GitHub Project

Explore all these patterns in code here:

👉 GitHub Repo

Each rate limiter is implemented in Python with comments and test files to help you understand and experiment.

🔧 How to Run the Code

Clone the repo

git clone https://github.com/arunsaiv/rate-limiter-patterns.git
cd rate-limiter-patterns

2. install dependencies

pip install -r requirements.txt

3. Run any pattern script

python fixed_window.py
python token_bucket.py

🙌 Like What You Read?

If this helped you:

💬 Leave a comment
🔁 Share it with your network
🌟 Star the GitHub repo!

Let's connect on LinkedIn!

Don’t Just Queue It — Master It! A Python Developer’s Guide to Queues

Arun Sai Veerisetty — Mon, 02 Jun 2025 00:26:03 +0000

🚀 Introduction

Queues are everywhere — from the print job waiting on your computer to the request processing system of a large-scale web server. But understanding queues isn’t just about putting items in and taking them out — it’s about knowing what kind of queue to use and when.

In this post, we’ll explore:

✅ Different types of queues
✅ How they’re implemented in Python
✅ Real-world scenarios where each type shines
✅ A practical GitHub repo with all code samples

Whether you’re prepping for interviews, building scalable backends, or just exploring Python data structures, this guide is for you.

📦 What is a Queue?

A queue is a First-In-First-Out (FIFO) data structure — like a line at the bank. The first person to arrive is the first to be served.

But modern systems use variations of queues to solve different problems. That’s what we’ll dive into next.

🧱 Queue Types & Use Cases

🎯 Simple Queue

• Behavior: FIFO
• Use Cases: Print queues, customer service systems, basic task scheduling
• Python: collections.deque or queue.Queue

🔁 Circular Queue

• Behavior: FIFO with a circular buffer (head connects to tail)
• Use Cases: Memory-efficient ring buffers, round-robin scheduling
• Python: Custom implementation (linked list or array-based)

⏫ Priority Queue

• Behavior: Elements are served based on priority
• Use Cases: Job scheduling, Dijkstra’s algorithm, OS-level tasks
• Python: queue.PriorityQueue, heapq

🔄 Deque (Double-Ended Queue)

• Behavior: Can insert/remove from both ends
• Use Cases: Undo/redo operations, sliding window problems, caching
• Python: collections.deque

🤝 Concurrent Queue

• Behavior: Thread-safe queue for multi-threaded systems
• Use Cases: Background processing, task pools, producer-consumer models
• Python: queue.Queue (thread-safe)

🧵 Curious about thread-safe? It means multiple threads can access the queue without data corruption or race conditions.

📩 Message Queue (Job Queue)

• Behavior: Asynchronous communication between producers & consumers
• Use Cases: Distributed systems, background job processing, microservices
• Popular Tools: RabbitMQ, Kafka, Redis Streams, Celery

🛠 Practical Examples & Code

Each queue is implemented in clean Python code in this GitHub repository:
👉 queue-patterns GitHub Repo

All implementations include:
• 🔍 Clear comments
• 🧪 Test cases
• ✅ Real-world applicability

📍 Why This Matters

Too often, people use one kind of queue for everything. Understanding which queue fits which problem leads to:
• More scalable systems
• Easier debugging
• Faster performance

Mastering queues isn’t just for computer science students — it’s for any developer working on backends, automation, data processing, or system design.

🙌 Found this helpful?

If you learned something new or found this guide useful, please consider:
• 💬 Leaving a comment — I’d love to hear your thoughts or questions!
• ❤️ Liking the post — it helps more developers discover this content.
• 🔄 Sharing it with others who might benefit.

Let’s keep learning and building together! 🚀

Let's connect on LinkedIn!

🚀 Chat With AI on Your Terminal – No API Key, No Limits, Just Python + Ollama

Arun Sai Veerisetty — Sat, 31 May 2025 21:12:26 +0000

Why should I use a terminal-based AI chatbot when ChatGPT is just a browser tab away?

That’s a valid question — and this blog will give you a very good answer.

Imagine this:
• You’re working offline or with limited internet.
• You want to explore open-source models like LLaMA 3 without any API restrictions.
• You want full control over what happens under the hood.
• You want to avoid rate limits and costs associated with commercial APIs.

If any of that resonates, this project is for you.

💡 The Problem with Web-Based AI

As amazing as ChatGPT is, there are still a few limitations:
• ⚠️ API costs add up fast if you’re prototyping regularly
• 🔒 Privacy concerns — your data is processed in the cloud
• 🌐 Requires a constant internet connection
• 📈 Rate limits on free or developer-tier APIs
• 🧪 Difficult to experiment with custom models or prompts

Sometimes, all you need is a simple, local environment to build and test — without worrying about tokens, keys, or infrastructure.

🔥 The Solution: A Local ChatGPT-Style CLI Tool

This project lets you build and run your own ChatGPT-style chatbot in the terminal using:
• 🐍 Python
• 🤖 Ollama – an open-source local runtime for LLMs
• ✅ Free & offline usage after the initial setup

You’ll be chatting with a powerful AI model like LLaMA 3 without needing an OpenAI key or an internet connection.

🧠 What Is Ollama?

Ollama makes running large language models (LLMs) on your own device incredibly easy. It supports:
• ⚡ Running LLaMA 3, Mistral, Gemma, and more
• 🌐 Serving models via a local HTTP API
• 🖥️ Compatible with macOS, Windows, and Linux

With just one command, you can run models that used to require massive infrastructure.

ollama run llama3

That’s it — it downloads and starts serving the model locally via http://localhost:11434.

🛠️ What We Built

We’ve built a cross-platform command-line chatbot with:
• 💬 Seamless terminal chat experience
• 🔁 Streaming responses like ChatGPT
• ⌛ A “thinking…” indicator for better UX
• 🧩 A pluggable design that can support any Ollama model
• 🚀 Designed to be beginner-friendly, open-source, and fast to set up

📦 GitHub Project

🧠 Repo: https://github.com/arunsaiv/ollama-cli-assistant

It’s open-source and beginner-friendly. You can clone it, run it, and tweak it.

🧰 Prerequisites

Python 3.8+
Ollama installed – Download Ollama
A supported LLM installed (e.g. ollama run llama3)

That’s all!

🏃‍♂️ How to Run the Chatbot

Clone and install:

git clone https://github.com/arunsaiv/ollama-cli-assistant.git
cd ollama-cli-assistant
pip install -r requirements.txt

make sure your model is running:

ollama run llama3

The launch the assistant:

python main.py

Start chatting!

🎥 What It Looks Like

You: What are embeddings?

💬 AI is thinking...

AI: Embeddings are numerical representations of data — such as words or sentences — that allow machines to understand and process language in a more meaningful way...

The response is streamed word-by-word, just like ChatGPT.

🧠 Why This Matters

This isn’t just a neat little side project — it’s your gateway to:
• 🔍 Learning how LLMs work under the hood
• 🧪 Running experiments without worrying about billing
• 🧱 Building AI tools and agents on top of open-source models
• 💡 Understanding prompt engineering by tweaking things yourself
• 🛠️ Customizing it to support additional commands, context, or tools

🧭 What You Can Build Next

This CLI is just the beginning. From here, you can:
• Add conversation memory
• Enable different models via CLI arguments
• Use voice input/output (via speech_recognition or gTTS)
• Build desktop wrappers with tools like Tauri or Electron
• Integrate with your own documents (RAG-style)

🏁 Wrap-Up

This project was born out of curiosity — can we build a truly offline, fully functional chatbot using open tools?

Turns out: Yes, and it’s awesome.

This CLI might not replace ChatGPT for everyone, but it gives you freedom, control, and insight into how LLMs really work — all while avoiding cloud limits.

📣 Final Thoughts

If this project helped you learn something, feel free to:
• ⭐ Star the GitHub repo
• 🗨️ Leave a comment or question below
• 🔁 Share this with someone who loves open-source AI
• 📬 Follow for more hands-on projects!

🔍 How OCR Engines Like Tesseract Work – From Image to Text

Arun Sai Veerisetty — Sat, 31 May 2025 00:57:47 +0000

Ever wondered how an app turns a scanned image into editable text? That’s the magic of OCR — Optical Character Recognition — and tools like Tesseract power much of this behind the scenes.

In this post, we’ll break down how OCR engines like Tesseract work, from reading pixels to returning readable characters.

📌 What is OCR?

OCR (Optical Character Recognition) is the process of converting images of printed or handwritten text into machine-readable digital text.

It’s widely used in:
• Digitizing documents and books
• Automating data entry from invoices, ID cards, forms
• Extracting text from scanned legal documents

• Building screen-scraping and automation tools

🧠 How OCR Works – Step-by-Step

Here’s a simplified pipeline of how OCR engines operate:

1️⃣ Image Preprocessing

Before OCR can recognize text, the image needs to be “cleaned up”:
• Grayscale Conversion – remove color distractions
• Noise Removal – remove shadows, blur, or background clutter
• Thresholding – convert the image to black and white to separate text from background
• Deskewing – straighten tilted documents

2️⃣ Text Detection and Segmentation

Once the image is clean:
• OCR locates text blocks on the page
• It segments lines, then words, then characters
• This is crucial — bad segmentation leads to bad recognition

3️⃣ Character Recognition

This is where the core OCR happens:
• Older engines used template matching
• Modern engines like Tesseract v4+ use LSTM-based deep learning to recognize characters
• It analyzes shapes, curves, and spacing to identify each character

4️⃣ Post-Processing

To improve accuracy:
• Spellchecking or dictionary matching
• Language modeling
• Reconstructing line breaks, paragraphs, and tables

🔧 How Tesseract Works (Under the Hood)

Tesseract is an open-source OCR engine maintained by Google.

Key features:
• Supports 100+ languages
• Uses LSTM (Long Short-Term Memory) neural networks for high accuracy
• Works best when paired with preprocessing libraries like OpenCV

Here’s a basic example using Python:

import pytesseract
from PIL import Image

text = pytesseract.image_to_string(Image.open("sample.png"))
print(text)

This simple script can extract readable text from almost any image.

⚠️ Common OCR Challenges

Even modern engines struggle with:
• Low-quality scans or handwritten text
• Tables, forms, or multi-column layouts
• Images with background patterns or logos
• Non-standard fonts or languages

That’s why OCR accuracy often depends heavily on preprocessing.

🛠 Real-World Use Case

In a previous project, I worked on automating the extraction of text from scanned IP (Intellectual Property) legal documents. Many of these had:
• Watermarks
• Inconsistent formatting
• Complex tables

By combining OpenCV preprocessing + Tesseract OCR, we achieved over 90% accuracy in text extraction — saving hours of manual review.

✅ Conclusion

OCR isn’t magic — it’s a combination of image processing, pattern recognition, and machine learning.

Tesseract makes it possible to implement OCR in just a few lines of code, but understanding how it works helps you fine-tune results and apply it to real-world projects.

python #ocr #tesseract #webdev #automation #canada