Forem: Sumanta Swain

Build a High-Performance RAG System with Gemini 2.5 Flash and FAISS 🚀

Sumanta Swain — Mon, 16 Feb 2026 18:23:17 +0000

Retrieval-Augmented Generation (RAG) is the gold standard for reducing LLM hallucinations and giving AI access to your private data. While there are many frameworks out there, building one from scratch gives you full control over the pipeline.

In this post, I’ll show you how to build a complete RAG system using Google’s Gemini API for embeddings and text generation, and FAISS for lightning-fast vector similarity search.

🏗️ The Tech Stack

LLM: Gemini 2.5 Flash (Fast, cost-effective, and powerful)
Embeddings: gemini-embedding-001
Vector Database: FAISS (Facebook AI Similarity Search)
Environment: Python 3.13+ with the uv package manager.

🛠️ How it Works: The Architecture

The system follows a three-step process:

Ingestion: We read .txt files, convert them into high-dimensional vectors using Gemini, and store them in a FAISS index.
Retrieval: When a user asks a question, we embed the query and find the most relevant document chunks using Cosine Similarity.
Generation: We feed the retrieved context + the original question into Gemini 2.5 Flash to generate a grounded, cited answer.

rag-implementation-gemini/
├── docs/                    # Place your .txt documents here
│   ├── doc1.txt            # Sample AI/ML content
│   └── doc2.txt            # Sample RAG content
├── main.py                 # Main application entry point
├── ingest_docs.py          # Document ingestion and embedding
├── rag_query.py            # Query processing and answer generation
├── test_rag.py             # Automated test suite
├── pyproject.toml          # Project dependencies
├── README.md               # This file
├── faiss_index.bin         # Generated FAISS index (after ingestion)
└── docs_meta.pkl           # Generated document metadata (after ingestion)

🚀 Getting Started

1. Setup

First, ensure you have your Google API Key from Google AI Studio.

I use the uv package manager for its incredible speed. If you haven't tried it yet, it’s a game-changer for Python workflows.

# Install dependencies
uv sync

# Set your API Key
export GOOGLE_API_KEY="your_api_key_here"

2. Document Ingestion (ingest_docs.py)

We use IndexFlatIP (Inner Product) on normalized vectors to perform Cosine Similarity. This ensures that even if the document lengths vary, the semantic relevance remains accurate.

import os
import pickle
from glob import glob
import numpy as np
import faiss
from dotenv import load_dotenv
from google import genai

load_dotenv()
API_KEY = os.environ.get("GEMINI_API_KEY")
if not API_KEY:
    raise SystemExit("Set GEMINI_API_KEY in .env or environment")

# initialize client (per Gemini docs)
client = genai.Client(api_key=API_KEY)

# choose the Gemini embedding model (example name; docs use gemini-embedding-001).
EMBED_MODEL = "gemini-embedding-001"

DOCS_DIR = "docs"
INDEX_FILE = "faiss_index.bin"
META_FILE = "docs_meta.pkl"

def read_documents(path):
    files = glob(os.path.join(path, "*.txt"))
    docs = []
    for p in files:
        with open(p, "r", encoding="utf-8") as f:
            text = f.read().strip()
        docs.append({"path": p, "text": text})
    return docs

def embed_texts(texts):
    # Call Gemini embeddings endpoint and normalize output to list of float vectors
    resp = client.models.embed_content(model=EMBED_MODEL, contents=texts)
    vectors = []
    for emb in resp.embeddings:
        # SDKs often return ContentEmbedding with `.values`; fallback to iterable
        if hasattr(emb, "values"):
            vec = np.array(emb.values, dtype="float32")
        else:
            vec = np.array(list(emb), dtype="float32")
        vectors.append(vec)
    return np.vstack(vectors)

def build_faiss_index(embs):
    dim = embs.shape[1]
    index = faiss.IndexFlatIP(dim)  # use inner product on normalized vectors (cosine)
    # Normalize if using IP for cosine:
    faiss.normalize_L2(embs)
    index.add(embs)
    return index

def main():
    docs = read_documents(DOCS_DIR)
    texts = [d["text"] for d in docs]
    if not texts:
        print("No docs found in", DOCS_DIR)
        return

    print(f"Embedding {len(texts)} docs with model {EMBED_MODEL} ...")
    embs = embed_texts(texts)  # shape: (N, dim)

    print("Building FAISS index...")
    index = build_faiss_index(embs)

    print("Saving index and metadata...")
    faiss.write_index(index, INDEX_FILE)
    with open(META_FILE, "wb") as f:
        pickle.dump(docs, f)

    print("Done. Index saved to", INDEX_FILE)

if __name__ == "__main__":
    main()

3. The Retrieval & Query Engine (rag_query.py)

The magic happens when we combine the retrieved snippets into a single prompt. We instruct the model to be a "helpful assistant" and, crucially, to cite its sources.

import os
import pickle
import numpy as np
import faiss
from dotenv import load_dotenv
from google import genai

load_dotenv()
# Support both GOOGLE_API_KEY and GEMINI_API_KEY for convenience
API_KEY = os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY")
if not API_KEY:
    raise SystemExit("Set GOOGLE_API_KEY or GEMINI_API_KEY in .env or environment")

client = genai.Client(api_key=API_KEY)
EMBED_MODEL = "gemini-embedding-001"
GEN_MODEL = "gemini-2.5-flash"   # example text generation model; pick one available to you

INDEX_FILE = "faiss_index.bin"
META_FILE = "docs_meta.pkl"

def embed_query(q):
    resp = client.models.embed_content(model=EMBED_MODEL, contents=[q])
    # extract the actual embedding values from ContentEmbedding object
    if hasattr(resp.embeddings[0], 'values'):
        vec = np.array(resp.embeddings[0].values, dtype="float32")
    else:
        # fallback if structure is different
        vec = np.array(list(resp.embeddings[0]), dtype="float32")
    # normalize for cosine (since index used normalized vectors)
    faiss.normalize_L2(vec.reshape(1, -1))
    return vec

def load_index():
    if not os.path.exists(INDEX_FILE) or not os.path.exists(META_FILE):
        raise SystemExit("Run ingest_docs.py first to build index.")
    index = faiss.read_index(INDEX_FILE)
    with open(META_FILE, "rb") as f:
        docs = pickle.load(f)
    return index, docs

def retrieve_topk(index, qvec, k=3):
    # qvec shape (dim,)
    q = qvec.reshape(1, -1)
    faiss.normalize_L2(q)  # ensure normalized
    scores, ids = index.search(q, k)
    return scores[0], ids[0]

def generate_answer(query, retrieved_texts):
    # Build a prompt that includes retrieved docs as context (short)
    context = "\n\n---\n\n".join(retrieved_texts)
    prompt = (
        "You are a helpful assistant. Use the following context to answer the question.\n\n"
        f"CONTEXT:\n{context}\n\nQUESTION:\n{query}\n\nAnswer concisely and cite which context file you used."
    )

    # call Gemini text generation (per docs)
    response = client.models.generate_content(
        model=GEN_MODEL,
        contents=prompt
    )
    # many SDKs have response.text or response.output; check your SDK return structure
    answer = getattr(response, "text", None) or response.output[0].content[0].text
    return answer

def main():
    index, docs = load_index()
    question = input("Enter your question: ").strip()
    qvec = embed_query(question)
    scores, ids = retrieve_topk(index, qvec, k=3)

    retrieved_texts = []
    for idx in ids:
        if idx < 0 or idx >= len(docs): 
            continue
        meta = docs[idx]
        retrieved_texts.append(f"FILE: {meta['path']}\n{meta['text'][:1000]}")  # limited preview

    print("\nRetrieved top documents (score, path):")
    for s, i in zip(scores, ids):
        if i >= 0 and i < len(docs):
            print(f"{s:.4f}  {docs[i]['path']}")

    print("\nGenerating answer using Gemini...")
    answer = generate_answer(question, retrieved_texts)
    print("\n=== Answer ===\n")
    print(answer)

if __name__ == "__main__":
    main()

🖥️ User Experience: The Interactive CLI

I built an interactive menu to make the system easy to use. You can toggle between ingesting new knowledge and asking questions instantly.

=== RAG with Gemini ===
1. Ingest documents
2. Ask a question
0. Exit

Enter your choice: 2
Enter your question: How does this RAG system handle vector search?

Retrieved top documents (score, path):
0.8921  docs/technical_specs.txt

Generating answer using Gemini...
=== Answer ===
This system utilizes FAISS with IndexFlatIP for similarity search. 
It normalizes embeddings to perform Cosine Similarity... [FILE: docs/technical_specs.txt]

💡 Why this approach?

Gemini 2.5 Flash: It offers a massive context window and rapid response times, making the "Generation" phase feel instantaneous.
FAISS: Instead of relying on a heavy cloud database for small-to-medium projects, FAISS is local, incredibly fast, and easy to deploy.
Transparency: By including Source Citations, we eliminate the "black box" feel of AI. The user knows exactly which document provided the answer.

🔧 Future Improvements

Chunking Strategy: Implement recursive character splitting for larger documents.
PDF Support: Add PyPDF2 or langchain loaders to handle more file types.
Web UI: Wrap this in Streamlit for a more modern interface.

🔗 Explore the Code

The full implementation is available on my GitHub:

(https://github.com/SumantaSwainEpam/rag-implementation-gemini)

I’d love to hear your thoughts! How are you handling document retrieval in your projects? Let’s discuss in the comments! 👇

The Death of Brittle Scripts: Architecting a Self-Healing AI Automation Ecosystem

Sumanta Swain — Mon, 15 Dec 2025 18:04:46 +0000

The "Monday Morning" Nightmare

Every SDET knows the feeling. You walk in on Monday morning, check the Jenkins pipeline, and see a sea of red.

Did the backend fail? No.
Did the database crash? No.
A frontend developer changed the ID of the "Submit" button from #submit-btn to #btn-submit-v2.

Traditional automation frameworks (Selenium, Cypress, Playwright) are imperative. They do exactly what they are told. If you tell them to find #submit-btn and it’s gone, they panic and crash. They lack Context.

We need to stop writing scripts that follow instructions and start architecting systems that understand Intent.

The Evolution: From SDET to AI Automation Architect

The industry is shifting. We are moving away from writing thousands of lines of boilerplate Java/Python code to manage page objects. The new role is the AI Automation Architect.

The goal? Build a centralized "Neuro-Engine" that handles the logic, while the scripts only define the goal.

Below is the architecture of "NeuroMate", a next-generation, self-healing automation ecosystem.

Decoding the Architecture

Let’s break down the diagram into its core zones to understand why this approach changes the game.

1. Zone A & B: The Polyglot Bridge (gRPC) 🌉

In a large enterprise, the Backend team might use Java, the Data team uses Python, and the Frontend team uses TypeScript. Forcing everyone to write tests in one language is a bottleneck.

The Solution: Decouple the "Test Definition" from the "Test Execution."

By using gRPC and Protocol Buffers, we create a universal contract. A QA Engineer can define a test intent in Java, Python, or C#. That intent is serialized and sent to the core engine. The test runner doesn't care about the language; it cares about the data.

2. Zone C: The Cognitive Core (The Brain) 🧠

This is where the magic happens. Standard frameworks use logic (If X then Y). This architecture uses Agents.

The Planner Agent: Instead of hardcoding steps, we give the agent a goal: "Buy the Red Shoes." The agent uses an LLM to look at the current page state and determine the 3 necessary steps to achieve that goal.
The DOM Analyzer: It parses the HTML not as text, but as a semantic tree, understanding that a "Magnifying Glass" icon usually means "Search," regardless of the class name.

3. Zone E: Hybrid Execution (Modern + Legacy) 🎭

We cannot just abandon legacy systems. A robust architecture must support both.

Playwright: Used for modern, high-speed execution on React/Vue apps.
Selenium: Kept for compatibility with legacy enterprise apps.
Appium: For mobile coverage.

The Core Engine decides which driver to use based on the target application, abstracting this complexity away from the user.

The "Secret Sauce": Visual Self-Healing ❤️‍🩹

The most critical part of this diagram is the Feedback Loop at the bottom.

The Scenario:
The script tries to click the "Pay Now" button using XPath //div[@id='pay'].
The app updates, and the ID is removed.

Standard Framework: NoSuchElementException. Crash. ❌

NeuroMate Framework:

Error Detection: The DOMParser catches the failure.
Healer Agent Activation: The system triggers the Self-Healing Agent.
Vision Lookup: The agent takes a screenshot of the page. It uses a Vision Model (like YOLO or CLIP) to find the element that visually looks like a "Pay Now" button near the "Total Price" text.
Auto-Patching: It clicks the button. If successful, it updates the Vector Database (Zone D) with the new selector.

The next time this test runs, it uses the new selector automatically. Zero human intervention required.

The Tech Stack

If you want to build this today, here is the recommended stack:

Orchestration: LangChain or LangGraph (Python)
API Layer: FastAPI with gRPC
Vision: OpenAI GPT-4o (Vision) or local YOLOv8
Memory: Qdrant or Weaviate (Vector DB)
Execution: Playwright Python

Conclusion

The future of QA isn't about writing better selectors; it's about eliminating the need for them entirely.

By adopting an AI Automation Architecture, we shift from being "Script Maintainers" to being "System Architects," building resilient platforms that adapt as fast as the software they test.

Unpopular Opinion: The Death of Prompt Engineering (Enter DSPy)

Sumanta Swain — Mon, 08 Dec 2025 18:51:56 +0000

The Problem with "Prompt Engineering"
We need to be honest with ourselves. "Prompt Engineering" as we know it today is not really engineering.

Spending 4 hours tweaking a string from "You are a helpful assistant" to "You are an expert professor" just to get a JSON output is not scalable. It's guessing. It is brittle. And if you change the underlying LLM (e.g., from GPT-4 to Claude 3), you often have to rewrite all your prompts.

The industry is shifting. We are moving from Hand-Crafted Strings to Compiled Logic.

Enter DSPy (Declarative Self-improving Python)

Developed by Stanford NLP, DSPy is a framework that treats language models like a compiler treats machine code.

Instead of writing prompts, you define Signatures (Inputs and Outputs).
Instead of manual tweaking, you use a Teleprompter (Optimizer) that automatically figures out the best prompt for your specific data.

It is the PyTorch of LLMs. You define the architecture (the logic), and DSPy optimizes the parameters (the prompts).

Show Me The Code
Here is a simple example. Notice that I never once write a string like "Please be helpful" or "Think step by step." DSPy handles that optimization for me.

The Output
When you run this, DSPy automatically injects a "Reasoning" step (Chain of Thought) because we used the dspy.ChainOfThought module. We didn't have to beg the LLM to "think step by step."

#Output
Prediction Object: Prediction(
   reasoning='The capital of India is New Delhi.',
   answer='New Delhi'
)
Reasoning: The capital of India is New Delhi.
Answer: New Delhi

Why This Matters
If you are building production AI applications, you cannot rely on brittle string templates.

Modularity: You can swap GPT-4 for Llama-3, and DSPy can re-optimize the prompts automatically.
Optimization: DSPy can actually learn from your data. If you give it 10 examples of good answers, it will rewrite its own prompts to maximize accuracy.
Clean Code: Your Python code looks like Python, not a wall of text.

Prompt Engineering isn't dead, but Manual Prompt Engineering is on its way out. It's time to start compiling.

Cursor vs Antigravity-The IDE Fight Nobody Asked For, But We Needed😂

Sumanta Swain — Thu, 27 Nov 2025 19:21:25 +0000

🧠 1. AI Coding Intelligence

Cursor:
🔥 Deep code understanding
🧩 Great for debugging & refactoring
📚 Best for large legacy projects

Antigravity:
⚡ Ultra-fast code generation
🪄 Insane auto-completion accuracy
💡 Predicts what you’ll code next 😅

Winner: Tie — depends on your style!

🎨 2. Developer Experience (DX)

Cursor:
🧼 Clean UI
📦 Git-friendly
🗺️ Project navigation feels natural

Antigravity:
🌌 Futuristic UI
🕹️ Sidebar dashboards
🎚️ Customizable everything

Winner: Antigravity (the UI is next-level)

🤖 3. AI Pair-Programming

Cursor:
👨‍🏫 More like a senior engineer guiding you
📝 Writes cleaner, safer code

Antigravity:
🧑‍🚀 More like a hyperactive junior dev
⚡ Generates LOT of code very fast
😅 Sometimes too enthusiastic

Winner: Cursor (for stability), Antigravity (for speed)

🧪 4. Test Automation

Cursor:
🛠️ Creates better test structures
🔍 Understands contexts deeply

Antigravity:
🧬 Great at generating boilerplate
⏱️ Faster test case creation

Winner: Cursor for quality, Antigravity for speed

🎯 5. Real-World Productivity

Cursor:
🎯 Better for complex enterprise apps
👨‍💻 Perfect for refactoring, debugging, testing
🤝 Works well with existing workflows

Antigravity
🚀 Perfect for building MVPs & prototypes
🎨 Creative coding, quick scaffolds
🧪 Experimentation heaven

Winner: Depends on your project.

🏆 Final Verdict (My Personal Take)

Building large/enterprise projects? → Cursor
Building fast prototypes / MVPs? → Antigravity
Want clean stable code? → Cursor
Want speed + fun? → Antigravity

Both are amazing just like we developers need more than one tool in the toolbox. 😂🔧

Meet UV: The Next-Gen Python Package Manager Built for Speed and Simplicity

Sumanta Swain — Thu, 30 Oct 2025 14:42:46 +0000

UV is a blazing-fast, modern Python package manager designed to simplify dependency management and virtual environments. Built with performance in mind, UV replaces traditional tools like pip, virtual env, and pip-tools by offering a unified, Rust-powered solution that dramatically speeds up installs and resolves dependencies with precision. Whether you're managing complex projects or just starting out, UV streamlines your workflow with minimal configuration and maximum efficiency.

Introduction

Python's evolution has always been closely tied to advancements in package management. From manual installations to modern tools like pip, poetry, and virtual env, developers have witnessed significant progress over the years. Yet, as projects grow larger and more complex, traditional tools often fall short in speed, efficiency, and usability—hindering developers from achieving smooth project workflows.

Enter UV, a next-gen Python package and project manager designed to address these shortcomings. Written in Rust, UV is a cutting-edge tool that combines the functionality of widely used tools like pip, poetry, and virtual env—but with exceptional performance, simplicity, and reliability.

In this article, we’ll explore UV, its unique features, benchmarks, step-by-step installation, and how developers can use it effectively for dependency management, virtual environments, Python installations, and more.

Why Does pip Fall Short?
What is UV?
Key Features of UV
Benchmarks
Installation Guide
Using UV for Virtual Environments
Building a Flask App with UV
Installing Python with UV
CLI Tools with UV
Cheat sheet for UV Operations
Current Limitations
Conclusion

Why Does pip Fall Short?

pip is unquestionably one of the most popular package management systems in Python, facilitating the installation and management of software packages. However, its limitations have been widely criticized by developers over the years:

Slow Installations: Developers often complain about the slowness of pip installations, especially in projects with numerous dependencies.
Dependency Smells: Poorly configured dependency files can lead to version conflicts, reduced maintainability, and increased project complexity.
Inconsistent Environment Restoration: Recreating runtime environments using pip often struggles to match Python code perfectly, leading to reliability issues during deployment.

What is UV?

UV is a modern, high-performance Python package manager, developed by the creators of ruff and written in Rust. It is designed as a drop-in replacement for tools like pip, pip-tools, and virtual env—while offering superior speed and functionality.

UV combines the best aspects of existing tools while incorporating innovative features that address common pain points in dependency management, environment creation, and project workflows. With cross-platform support (Linux, macOS, and Windows) and extensive testing against the PyPI index, UV aims to simplify Python development for both new and experienced programmers.

Key Features of UV

UV stands out from traditional package management tools due to its impressive features:

⚖️ Drop-in Compatibility: Seamlessly replaces pip, pip-tools, and virtual env with minimal friction.
⚡ Blazing Speed: Up to 100x faster than pip for dependency resolution and installation.
💾 Efficient Disk Space Usage: Minimizes storage usage using global dependency caching.
🐍 Flexible Installation Options: Installable via curl, pip, pipx, or natively via package managers like Homebrew and Pacman.
🧪 Thorough Testing: Verified for scale on over 10,000 PyPI packages.
🖥️ Cross-Platform Support: Compatible with macOS, Linux, and Windows.
🔩 Advanced Dependency Management: Offers alternative resolution strategies, conflict tracking, and version overrides.
🚀 Unified Tooling: Combines features of pip, poetry, pyenv, twine, and related tools into a single solution.
🏢 Workspace Management: Simplifies scalable projects with Cargo-style workspace handling.

Benchmarks

UV’s speed is one of its defining features. It is significantly faster than traditional tools in environments with both warm and cold caches:

Installation

Installing uv is quick and straightforward. You can opt for standalone installers or install it directly from PyPI.

# On macOS and Linux.
curl -LsSf https://astral.sh/uv/install.sh | sh

# On Windows.
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

# With pip.
pip install uv

# With pipx.
pipx install uv

# With Homebrew (Mac).
brew install uv

# With Pacman (Linux).
pacman -S uv

Using UV for Virtual Environments

Creating and activating virtual environments with UV is straightforward:

# Create a Virtual Environment
uv venv

# Activate the Virtual Environment On(macOS/Linux):
source .venv/bin/activate

# On Windows
.venv\Scripts\activate

# Installing packages follows standard commands:
uv pip install flask                       # Install Flask.  
uv pip install -r requirements.txt         # Install from a file.

Building a Flask App with UV

Here’s how to use UV to set up and run a Flask applications.

Installing Python Versions with UV

UV can optionally install Python versions with ease:

# Install Specific Python Version
uv python install 3.12

CLI Tools with UV

UV supports installing CLI tools like huggingface_hub:

uv tool install huggingface_hub
uv tool list                       # Lists all installed tools.

UV Commands Cheat Sheet

# Virtual Environment Management
uv venv                                # Create a virtual environment
uv activate                            # Activate the virtual environment
uv deactivate                          # Deactivate the virtual environment

# Dependency Management
uv pip install flask                   # Install 'flask' dependency
uv pip install <package>==<version>    # Install a specific version of a package
uv pip list                            # List installed dependencies in the current environment
uv pip uninstall <package>             # Uninstall a package

# Running Python Scripts
uv run script.py                       # Run Python script located at "script.py"
uv python                              # Start Python REPL in the UV environment

# Python Version Management
uv python install 3.12                 # Install Python version 3.12
uv python list                         # List Python versions available or installed
uv python use 3.12                     # Use Python version 3.12

# CLI Tool Management
uv tool install <tool>                 # Install a CLI tool
uv tool list                           # List installed CLI tools
uv tool update <tool>                  # Update a CLI tool
uv tool uninstall <tool>               # Uninstall a CLI tool

# Miscellaneous
uv --version                           # Check UV version
uv help                                # Display help menu for UV commands
uv pip freeze > requirements.txt       # Generate a `requirements.txt` file of installed packages
uv pip install -r requirements.txt     # Install dependencies from `requirements.txt`

Current Limitations

While UV is promising, it isn’t perfect:

Incomplete Compatibility with Pip: UV doesn’t yet cover all pip features, though its minimalist design compensates for this gap.
Platform-Specific Requirements Files: Like pip-compile, UV generates platform-specific requirements files, which may limit portability across operating systems.

Conclusion

UV is not just another Python package manager—it’s a game-changer that eliminates common developer frustrations. With its speed, simplicity, and modern features, UV represents the future of Python dependency management.

Disclaimer:
This is a personal blog. The views and opinions expressed here are only those of the author and do not represent those of any organization or any individual with whom the author may be associated, professionally or personally.

Forem: Sumanta Swain

Build a High-Performance RAG System with Gemini 2.5 Flash and FAISS 🚀

🏗️ The Tech Stack

🛠️ How it Works: The Architecture

🚀 Getting Started

🖥️ User Experience: The Interactive CLI

💡 Why this approach?

🔧 Future Improvements

🔗 Explore the Code

The Death of Brittle Scripts: Architecting a Self-Healing AI Automation Ecosystem

The "Monday Morning" Nightmare

The Evolution: From SDET to AI Automation Architect

Decoding the Architecture

1. Zone A & B: The Polyglot Bridge (gRPC) 🌉

2. Zone C: The Cognitive Core (The Brain) 🧠

3. Zone E: Hybrid Execution (Modern + Legacy) 🎭

The "Secret Sauce": Visual Self-Healing ❤️‍🩹

The Tech Stack

Conclusion

Unpopular Opinion: The Death of Prompt Engineering (Enter DSPy)

Cursor vs Antigravity-The IDE Fight Nobody Asked For, But We Needed😂

Meet UV: The Next-Gen Python Package Manager Built for Speed and Simplicity

Introduction

Table of Contents

Why Does pip Fall Short?

What is UV?

Key Features of UV

Benchmarks

Installation

Using UV for Virtual Environments

Building a Flask App with UV

Installing Python Versions with UV

CLI Tools with UV

UV Commands Cheat Sheet

Current Limitations

Conclusion