# Norwegian RAG Chatbot Project Structure

## Overview
This document outlines the project structure for our lightweight Norwegian RAG chatbot implementation that uses Hugging Face's Inference API instead of running models locally.

## Directory Structure
```
chatbot_project/
├── design/                  # Design documents
│   ├── rag_architecture.md
│   ├── document_processing.md
│   └── chat_interface.md
├── research/                # Research findings
│   └── norwegian_llm_research.md
├── src/                     # Source code
│   ├── api/                 # API integration
│   │   ├── __init__.py
│   │   ├── huggingface_api.py  # HF Inference API integration
│   │   └── config.py        # API configuration
│   ├── document_processing/ # Document processing
│   │   ├── __init__.py
│   │   ├── extractor.py     # Text extraction from documents
│   │   ├── chunker.py       # Text chunking
│   │   └── processor.py     # Main document processor
│   ├── rag/                 # RAG implementation
│   │   ├── __init__.py
│   │   ├── retriever.py     # Document retrieval
│   │   └── generator.py     # Response generation
│   ├── web/                 # Web interface
│   │   ├── __init__.py
│   │   ├── app.py           # Gradio app
│   │   └── embed.py         # Embedding functionality
│   ├── utils/               # Utilities
│   │   ├── __init__.py
│   │   └── helpers.py       # Helper functions
│   └── main.py              # Main application entry point
├── data/                    # Data storage
│   ├── documents/           # Original documents
│   └── processed/           # Processed documents and embeddings
├── tests/                   # Tests
│   ├── test_api.py
│   ├── test_document_processing.py
│   └── test_rag.py
├── venv/                    # Virtual environment
├── requirements-ultra-light.txt  # Lightweight dependencies
├── requirements.txt         # Original requirements (for reference)
└── README.md                # Project documentation
```

## Key Components

### 1. API Integration (`src/api/`)
- `huggingface_api.py`: Integration with Hugging Face Inference API for both LLM and embedding models
- `config.py`: Configuration for API endpoints, model IDs, and API keys

### 2. Document Processing (`src/document_processing/`)
- `extractor.py`: Extract text from various document formats
- `chunker.py`: Split documents into manageable chunks
- `processor.py`: Orchestrate the document processing pipeline

### 3. RAG Implementation (`src/rag/`)
- `retriever.py`: Retrieve relevant document chunks based on query
- `generator.py`: Generate responses using retrieved context

### 4. Web Interface (`src/web/`)
- `app.py`: Gradio web interface for the chatbot
- `embed.py`: Generate embedding code for website integration

### 5. Main Application (`src/main.py`)
- Entry point for the application
- Orchestrates the different components

## Implementation Approach

1. **Remote Model Execution**: Use Hugging Face's Inference API for both LLM and embedding models
2. **Lightweight Document Processing**: Process documents locally but use remote APIs for embedding generation
3. **Simple Vector Storage**: Store embeddings in simple file-based format rather than dedicated vector database
4. **Gradio Interface**: Create a simple but effective chat interface using Gradio
5. **Hugging Face Spaces Deployment**: Deploy the final solution to Hugging Face Spaces