rag-backend

Document FastAPI, Ollama, and pgvector backend architecture and operational runbooks.

Updated Apr 6, 2026
One-click install
npx skills add https://github.com/MikkoNumminen/mikkonumminen.dev --skill rag-backend
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rag-backend
Source: https://github.com/MikkoNumminen/mikkonumminen.dev/tree/main/.claude/skills/rag-backend
Command: npx skills add https://github.com/MikkoNumminen/mikkonumminen.dev --skill rag-backend

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a comprehensive architectural map and operational guide for the local RAG chat backend, preventing the need to re-derive complex system configurations or debug environment drifts from scratch.

Core Features & Use Cases

  • System Architecture Mapping: Provides deep insights into the FastAPI, Ollama, and pgvector stack, including the exact chat pipeline order and containment layers.
  • Operational Troubleshooting: Offers a clear runbook for corpus management, re-indexing, and resolving environment-specific gotchas between Windows and WSL.
  • Use Case: When debugging chat response latency or model behavior, use this Skill to quickly identify the correct log paths, configuration knobs, and the specific retrieval pipeline logic without manually parsing the entire codebase.

Quick Start

Use the rag-backend skill to retrieve the current configuration settings and the operational status of the local chat service.

Frequently Asked Questions about rag-backend

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I maintain a local RAG backend using FastAPI, Ollama, and pgvector?

To maintain a local RAG backend, you need structured environment mapping and pipeline analysis to manage FastAPI, Ollama, and pgvector components. This prevents re-deriving complex system configurations and resolves environment drifts without debugging from scratch.

What is the best way to troubleshoot chat response latency in a RAG pipeline?

Troubleshooting chat response latency in a RAG pipeline requires identifying correct log paths, configuration knobs, and retrieval pipeline logic. Using an architectural map helps pinpoint specific containment layers and pipeline order without manually parsing the codebase.

How do I re-index a corpus in a local retrieval-augmented-generation backend?

Re-indexing a corpus in a local retrieval-augmented-generation backend requires following defined operational runbooks. These structured procedures ensure consistent system performance by guiding configuration management and preventing environment-specific drifts.

Does the RAG chat stack work with WSL on Windows?

The RAG chat stack works with WSL on Windows by addressing specific environment gotchas. Operational runbooks provide troubleshooting steps to resolve configuration drifts and ensure consistent system performance across Windows and WSL containment layers.

Why do I need architectural documentation for my FastAPI and Ollama stack?

Architectural documentation for a FastAPI and Ollama stack is needed to prevent debugging environment drifts from scratch. It provides deep insights into the exact chat pipeline order and containment layers, ensuring consistent system performance.

What are the limitations of manually parsing a local RAG codebase for configuration?

Manually parsing a local RAG codebase for configuration limits your ability to quickly resolve environment drifts and chat latency. It lacks structured environment mapping and pipeline analysis, leading to inconsistent system performance and configuration management issues.