RideFix Bro: A RAG-Powered Motorcycle Repair AI That Actually Reads 500-Page Manuals

When a Chatbot Learns to Read the Manual

Most AI assistants just guess from memory during a conversation. That's why a developer (GitHub user GeeTansher) caught attention on Reddit when he shared RideFix Bro — an AI assistant built specifically for motorcycle repair. Its core differentiator: instead of just chatting, it actually reads through 500-page official repair manuals cover to cover, and can reach out to the live web when it needs real-world rider experience.

The project includes both a backend architecture and an Android client, making it a complete RAG (Retrieval-Augmented Generation) + Agentic AI system. For developers looking to understand how to deploy LLMs in vertical domains, it provides a fairly complete engineering reference.

The Biggest Challenge: Not Crashing the Server

The developer openly admits that the trickiest part of the project wasn't the AI conversation itself — it was how to convert massive PDF manuals into vector embeddings without triggering timeouts or API rate limits.

A 500-page technical manual means enormous amounts of text that need to be chunked, embedded, and written to a vector database. With traditional synchronous processing, Azure servers would easily time out and the Gemini API would quickly hit rate limits.

His solution was Durable Background Processing: replacing synchronous handling with ASP.NET Core's BackgroundService, performing chunking and embedding generation in the background, and saving progress checkpoints to Azure SQL. This way, even if the server restarts, the task can resume from exactly where it left off rather than starting over. It's a highly practical engineering approach for large-scale document ingestion.

Vector embeddings convert text into high-dimensional numerical vectors, where semantically similar text sits closer together in vector space — enabling "semantic search" rather than traditional keyword matching. Chunking splits long documents into smaller pieces suitable for embedding models; chunk size directly affects retrieval accuracy: too large introduces noise, too small loses context. A 500-page manual might produce thousands of chunks, each requiring a separate API call to generate embeddings — which is exactly why batch processing so easily triggers rate limits. Most free or low-cost tiers only allow a limited number of calls per minute. Checkpointing works like a game save, recording the index of successfully processed chunks so a job can resume from the breakpoint after an unexpected interruption rather than restarting from scratch — an essential reliability mechanism for document ingestion tasks that can take minutes or even hours.

Agentic Orchestration: The AI Decides Whether to Check the Manual or Search the Web

The intelligent core of RideFix Bro is its Agentic orchestration layer. The developer uses Microsoft's AutoGen framework to coordinate two data sources:

• Google Gemini: handles understanding and generation
• Tavily: handles real-time web search
• Qdrant (vector database): stores the official manual's embedding data

The key design: the AI dynamically decides when to retrieve authoritative answers from Qdrant's manual data, and when to turn to web search for real-world repair experience accumulated by riders in forums and communities. This ability to automatically switch between "authoritative documentation" and "community knowledge" is what makes Agentic AI a step above ordinary RAG systems.

The developer also mentioned that to keep Gemini API and AutoGen communicating reliably, he wrote a dedicated middleware layer to handle Gemini API's "mood swings" (rate limits, unexpected responses, etc.) — the kind of unglamorous engineering work that's easy to underestimate in practice.

AutoGen is Microsoft's open-source multi-agent orchestration framework, allowing developers to define multiple Agents with different capabilities and have them collaborate to complete tasks. Unlike a simple single-pass RAG pipeline, an Agentic system's AI can initiate multi-step reasoning within a single user request: first classify the question type, then select the appropriate tool (query the vector store or call the search API), and finally synthesize results from multiple sources into a response. Tavily is a search API designed specifically for AI applications; compared to calling Google Search directly, it automatically extracts page content and returns it in a structured format, reducing the complexity of having the LLM process raw HTML. This dual-track routing strategy of "authoritative documentation + real-time community experience" neatly addresses the limitation that official manuals often don't cover real-world edge cases.

Client-Side Security and Cloud-Native Architecture

On the mobile side, the frontend is built entirely with Kotlin / Jetpack Compose, with considerable attention paid to security:

• AES-256-GCM encryption backed by the Android Keystore to protect mobile sessions
• Supabase Auth for identity management

The backend follows a cloud-native approach, deployed on Azure App Service and using Managed Identity for password-free secure access to Azure SQL — eliminating the need to hard-code database credentials in code or configuration files, which is the recommended practice for cloud security.

The complete tech stack: C# | .NET 10 | Kotlin | Jetpack Compose | AutoGen | Gemini | Qdrant | Azure SQL | Supabase.

Azure Managed Identity is a password-free authentication mechanism provided by the Azure platform: a cloud service (such as App Service) is assigned an identity credential automatically managed by the platform, allowing it to access other resources within the same Azure tenant (such as Azure SQL or Key Vault) without storing any keys in code or configuration files. This fundamentally eliminates "credentials leaked in the code repository" — the most common source of cloud security incidents. The Android Keystore is Android's hardware-level key storage mechanism: AES-256-GCM keys are generated and locked within the device's secure chip. Application code itself cannot export the raw key, and even if the APK is reverse-engineered, the encryption key cannot be retrieved — providing strong hardware-level protection for locally stored session tokens.

A Vertical RAG Template Worth Borrowing

Beyond the specific use case of motorcycle repair, RideFix Bro's real value lies in demonstrating a reusable path for deploying AI in vertical domains:

1. Reliably ingest massive professional documents as vector data
2. Use an Agent to intelligently route between "authoritative sources" and "real-time web"
3. Implement security hardening on both the client and cloud sides

This combination can be transferred to almost any industry that requires consulting thick manuals — automotive repair, medical devices, legal regulations, industrial equipment, and more.

One caveat: since the project currently runs on free service tiers, the developer added a rate limiter and noted that anyone interested in testing it can contact him to be added to a whitelist. In other words, this is still an early-stage personal project, not a mature product. The project is open-sourced on GitHub (repo name: Ride-Fix-Bro), and interested developers can dive directly into the architecture.

Summary

RideFix Bro doesn't invent any entirely new technology, but it assembles RAG, Agentic orchestration, durable background processing, and mobile security into a complete, working system. For developers learning how to build production-grade AI applications, its engineering details — especially the use of background services with checkpoint resumption to solve rate-limiting problems during large document embedding — offer more practical insight than its ability to "know motorcycles" ever could.