Update README.md

README.md

@@ -8,4 +8,63 @@ app_file: app.py
 pinned: false
 license: mit
 short_description: RAG + LoRA Fine-Tuning for Code Analysis
----
+---
+
+# Fine-tuned LLM with RAG for Codebase Analysis
+
+This project demonstrates a production-ready, sophisticated Retrieval-Augmented Generation (RAG) system specifically engineered for codebase analysis. Its core innovation is the **automatic fine-tuning** of a code-specialized language model (`Salesforce/codegen-350M-mono`) on startup. This process creates a highly specialized expert model that provides accurate, context-aware, and reliable answers to complex software engineering questions.
+
+The system is designed to be a transparent and robust framework, featuring detailed performance evaluation, cost tracking, and clear source attribution for every generated response.
+
+## Core Features
+
+This system integrates a complete, automated pipeline for building and querying a specialized code analysis engine.
+
+* **Automatic Model Fine-Tuning**: On initialization, the system automatically fine-tunes the `Salesforce/codegen-350M-mono` model using Parameter-Efficient Fine-Tuning (PEFT/LoRA). This process adapts the model to the specific nuances of software development Q&A, significantly improving its accuracy and relevance.
+
+* **Retrieval-Augmented Generation (RAG)**: The framework leverages a `ChromaDB` vector store and a `sentence-transformers` model to create and query a knowledge base. When a question is asked, the system retrieves the most relevant document chunks to ground the language model's response in factual, verifiable information.
+
+* **Code-Specific Language Model**: The entire system is built upon `Salesforce/codegen-350M-mono`, a powerful model pre-trained specifically on code. This provides a strong foundation for understanding programming concepts, syntax, and architecture.
+
+* **Comprehensive Evaluation Metrics**: Every response is critically evaluated in real-time. The system calculates and displays scores for:
+    * **Relevance**: How closely the answer matches the user's query.
+    * **Context Grounding**: How well the answer is supported by the retrieved documents.
+    * **Hallucination Score**: An estimation of how much the model deviates from the provided context (lower is better).
+    * **Technical Accuracy**: A measure of the response's use of correct technical terminology.
+
+* **Performance & Cost Tracking**: A built-in `PerformanceTracker` monitors key operational metrics, including query latency, the number of tokens processed, and the estimated cost of each interaction, providing insights needed for production deployment.
+
+* **Source Attribution**: To ensure transparency and trust, the system clearly cites the source documents that were used to formulate each answer.
+
+## How It Works
+
+The system follows an automated, multi-stage process to deliver high-quality codebase analysis.
+
+1.  **Initialization & Fine-Tuning**: On the very first run, the system fine-tunes the base CodeGen model using a curated dataset of software development Q&A. This one-time process creates a specialized LoRA adapter, which is then loaded for all subsequent operations.
+2.  **Knowledge Ingestion**: A knowledge base of software engineering documents (covering architecture, testing, best practices, etc.) is processed. Each document is split into manageable chunks, converted into vector embeddings, and indexed into a `ChromaDB` vector store.
+3.  **Query & Retrieval**: When a user submits a query, the system embeds the question and searches the vector store to find the most semantically similar document chunks.
+4.  **Augmented Generation**: The user's query and the retrieved context chunks are combined into a detailed prompt. This prompt is then passed to the fine-tuned language model, which generates a comprehensive, context-aware answer.
+5.  **Evaluation & Presentation**: The final answer, its sources, and the full suite of performance and quality metrics are presented to the user in a clean, interactive Gradio dashboard.
+
+## Technical Stack
+
+* **LLM & Fine-Tuning**: Transformers, PEFT (LoRA), PyTorch, BitsAndBytes
+* **Retrieval & Embeddings**: ChromaDB, Sentence-Transformers, LangChain
+* **Core Data Science**: Pandas, NumPy, Scikit-learn
+* **Web Interface**: Gradio
+* **Core Language**: Python
+
+## How to Use the Demo
+
+The interface is designed for simplicity and clarity.
+
+1.  **Wait for Initialization**: The first time the application starts, it will perform the automatic fine-tuning process. A status banner will indicate when the fine-tuned model is active.
+2.  **Ask a Question**: Use the text box to ask a question related to software development, such as "What are microservices architecture?" or "Explain test-driven development."
+3.  **Analyze Query**: Click the "Analyze Query" button to submit your question.
+4.  **Review the Results**:
+    * The generated **Analysis Result** will appear on the left.
+    * The **Referenced Sources**, **Response Metrics**, and **Performance Data** will be displayed on the right, giving you a complete overview of the system's operation for your query.
+
+## Disclaimer
+
+This application is a demonstration of a sophisticated RAG and fine-tuning pipeline. The knowledge base is pre-loaded with general software engineering documents and does not reflect any specific proprietary codebase.