ade

app.py

@@ -260,10 +260,10 @@ if __name__ == "__main__":
         else:
             print("⚠️ Connected Mode disabled: ADK components not initialized.")
 
-        if STORY_LLM:
-            story_mode_ui = create_story_mode_ui()
-            interface_list.append(story_mode_ui)
-            tab_titles.append("Farmer's Story Mode")
+                # Add the new Document Analysis UI
+        document_analysis_ui = create_document_analysis_ui()
+        interface_list.append(document_analysis_ui)
+        tab_titles.append("Document Analysis")
         else:
             print("⚠️ Farmer's Story Mode disabled: Story LLM not initialized.")
     else:

config.py

@@ -6,7 +6,7 @@ ADAPTER_PATH = "surfiniaburger/maize-health-diagnosis-adapter"
 EMBEDDING_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
 
 # RAG and Knowledge Base
-KNOWLEDGE_BASE_PATH = "knowledge_base.md"
+KNOWLEDGE_BASE_PATH = "knowledge_base_data"
 FAISS_INDEX_PATH = "faiss_index"
 
 # Model Parameters

document_analyzer.py

@@ -0,0 +1,104 @@
+import os
+from PyPDF2 import PdfReader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.chains.question_answering import load_qa_chain
+from langchain_community.llms import HuggingFaceHub
+import config
+
+def analyze_pdf(file_path):
+    """
+    Analyzes a PDF file and returns a question-answering chain.
+
+    Args:
+        file_path: The path to the PDF file.
+
+    Returns:
+        A Langchain QA chain object.
+    """
+    try:
+        pdf_reader = PdfReader(file_path)
+        text = ""
+        for page in pdf_reader.pages:
+            text += page.extract_text()
+
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=200,
+            length_function=len
+        )
+        chunks = text_splitter.split_text(text=text)
+
+        embeddings = HuggingFaceEmbeddings(model_name=config.EMBEDDING_MODEL_NAME)
+        vector_store = FAISS.from_texts(chunks, embedding=embeddings)
+
+        llm = HuggingFaceHub(repo_id="google/flan-t5-xxl", model_kwargs={"temperature":0.5, "max_length":512})
+        chain = load_qa_chain(llm=llm, chain_type="stuff")
+
+        return chain, vector_store
+
+    except Exception as e:
+        print(f"Error analyzing PDF: {e}")
+        return None, None
+
+def query_pdf(chain, vector_store, query):
+    """
+    Queries the PDF using the QA chain.
+
+    Args:
+        chain: The Langchain QA chain object.
+        vector_store: The FAISS vector store.
+        query: The question to ask the PDF.
+
+    Returns:
+        The answer to the query.
+    """
+    try:
+        docs = vector_store.similarity_search(query=query, k=3)
+        answer = chain.run(input_documents=docs, question=query)
+        return answer
+    except Exception as e:
+        print(f"Error querying PDF: {e}")
+        return "Sorry, I couldn't find an answer to your question in the PDF."
+
+import pandas as pd
+from langchain_experimental.agents.agent_toolkits import create_pandas_dataframe_agent
+from langchain_community.llms import HuggingFaceHub
+
+def analyze_spreadsheet(file_path):
+    """
+    Analyzes a spreadsheet file and returns a question-answering agent.
+
+    Args:
+        file_path: The path to the spreadsheet file.
+
+    Returns:
+        A Langchain agent object.
+    """
+    try:
+        df = pd.read_csv(file_path)
+        llm = HuggingFaceHub(repo_id="google/flan-t5-xxl", model_kwargs={"temperature":0.5, "max_length":512})
+        agent = create_pandas_dataframe_agent(llm, df, verbose=True)
+        return agent
+    except Exception as e:
+        print(f"Error analyzing spreadsheet: {e}")
+        return None
+
+def query_spreadsheet(agent, query):
+    """
+    Queries the spreadsheet using the agent.
+
+    Args:
+        agent: The Langchain agent object.
+        query: The question to ask the spreadsheet.
+
+    Returns:
+        The answer to the query.
+    """
+    try:
+        answer = agent.run(query)
+        return answer
+    except Exception as e:
+        print(f"Error querying spreadsheet: {e}")
+        return "Sorry, I couldn't find an answer to your question in the spreadsheet."

knowledge_base.py

@@ -15,18 +15,30 @@ def get_retriever():
     try:
         embeddings = HuggingFaceEmbeddings(model_name=config.EMBEDDING_MODEL_NAME)
 
+        # Force rebuild of the FAISS index
         if os.path.exists(config.FAISS_INDEX_PATH):
-            print(f"✅ Loading existing FAISS index from {config.FAISS_INDEX_PATH}...")
-            db = FAISS.load_local(config.FAISS_INDEX_PATH, embeddings, allow_dangerous_deserialization=True)
-        else:
-            print(f"⚠️ FAISS index not found. Building a new one from {config.KNOWLEDGE_BASE_PATH}...")
-            loader = TextLoader(config.KNOWLEDGE_BASE_PATH)
-            documents = loader.load()
-            text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
-            docs = text_splitter.split_documents(documents)
-            db = FAISS.from_documents(docs, embeddings)
-            db.save_local(config.FAISS_INDEX_PATH)
-            print(f"✅ New FAISS index built and saved to {config.FAISS_INDEX_PATH}.")
+            print(f"🗑️ Deleting existing FAISS index from {config.FAISS_INDEX_PATH}...")
+            import shutil
+            shutil.rmtree(config.FAISS_INDEX_PATH)
+
+        print(f"⚠️ Building a new FAISS index from all files in {config.KNOWLEDGE_BASE_PATH}...")
+        
+        documents = []
+        data_path = config.KNOWLEDGE_BASE_PATH
+        for file_name in os.listdir(data_path):
+            file_path = os.path.join(data_path, file_name)
+            if os.path.isfile(file_path) and file_name.endswith('.txt'):
+                print(f"  - Loading {file_name}...")
+                loader = TextLoader(file_path)
+                documents.extend(loader.load())
+
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
+        docs = text_splitter.split_documents(documents)
+        
+        print("\n✨ Creating new FAISS index...")
+        db = FAISS.from_documents(docs, embeddings)
+        db.save_local(config.FAISS_INDEX_PATH)
+        print(f"✅ New FAISS index built and saved to {config.FAISS_INDEX_PATH}.")
 
         retriever = db.as_retriever(search_kwargs={"k": 1})
         print("✅ RAG knowledge base and retriever created successfully!")

knowledge_base_data/comic_relief.txt

@@ -0,0 +1,2 @@
+"Wetin My Eye See So?"
+"Ah! Oga/Madam farmer, this one pass my power o. I don look this picture soteh my eye dey turn. E be like say this thing no be corn at all o, or maybe na some new style of corn wey dem just invent for another planet. Abeg, you fit try another picture? Make my brain no go knock before you come back. No vex!"

knowledge_base_data/healthy_maize_remedy.txt

@@ -0,0 +1,7 @@
+"So your farm don produce beta corn? Oya, make we see different ways you fit enjoy am with your family. Corn no be for roasting alone!"
+"Better Ways to Enjoy Your Healthy Corn (Maize)"
+"Agbado (Roasted Corn) and Ube (Pear):Dis one na classic street food for Naija. Just roast your fresh corn over charcoal fire until e brown small. Eat am with soft pear wey you don roast small or boil inside hot water. Di sweetness of di corn and di creamy pear na match made in heaven!"
+"Boiled Corn: Simple and sweet. Just remove di husk (di green leaf), put di corn inside pot with water and small salt. Cook am until di corn soft. You fit chop am like dat or with coconut. E dey very sweet and filling."
+"Pap (Akamu or Ogi): For dis one, you go need dry corn. Soak di corn for water for like two or three days until e soft. Grind am well well into a paste. Use clean cloth or sieve to separate di smooth paste from di chaff (di rough part). Allow di smooth paste to siddon and ferment small for one day. To prepare am, just mix small of di paste with cold water, then pour hot water on top and stir fast fast until e thick. Enjoy am with akara, moin moin, or milk and sugar."
+"Tuwo Masara:This na like swallow for northern people. You go grind dry corn into a fine powder (corn flour). Put water for pot and make e boil. Mix small of di corn flour with cold water to make a paste, then pour am inside di boiling water and stir well. As e de thick, de add more of di dry flour small small and de turn am with turning stick until e strong like semo or eba. Serve am with any soup like Miyan Kuka or Miyan Taushe."
+"Egusi and Corn Soup:You fit add fresh corn to your egusi soup! When you don fry your egusi finish and add your meat and fish, just cut fresh corn from di cob and pour am inside di soup. Allow am to cook for like 10-15 minutes. Di sweetness of di corn go make your egusi soup taste different and special."

knowledge_base_data/maize_phosphorus_deficiency_remedy.txt

@@ -0,0 +1,10 @@
+"How You Fit Solve Phosphorus Problem for Your Corn (Maize)"
+"If your corn leaves de turn purple or dark green, especially when di plant still small, e fit be say phosphorus no reach am. Phosphorus be like power food for di plant root and for making seed."
+"Wetin You Go Do Sharp Sharp (Short-Term Solution)"
+"Bone Meal: Go market, buy bone meal. Na ground-up animal bone and e full with phosphorus. Sprinkle small quantity around di base of your corn plant and mix am small with di soil. No let am touch di plant stem direct."
+"Fish Fertilizer (Fish Tea): If you fit get fish head or bones, soak dem inside water for some days. Di water go turn to strong fertilizer. Mix one cup of this fish tea with ten cups of plain water, and use am water your corn one time in a week."
+"Wetin You Go Do for Future Planting (Long-Term Solution)"
+"Chicken Manure (Fowl Yansh): Before you plant next time, make sure you add well-decayed chicken manure to your soil. Fowl yansh get plenty phosphorus. No use fresh one, e dey too strong and e go burn your plant. Make sure e don dry well well."
+"Plant Legumes: Plant beans (cowpea) or groundnut for di land before you plant corn again. Dis plants de help make di soil rich and e go help free up phosphorus for di next crop."
+"Check Your Soil pH: Sometimes, di phosphorus dey inside di soil but di soil too strong (acidic) for di plant to chop am. You fit add small wood ash to di soil before you plant. E go help balance di soil and make di phosphorus available for di corn."
+"Remember, small small na im dem de take chop hot soup. Start with small quantity of fertilizer, watch your plant, and add more if you need am."

miscellaneous/offline.md

@@ -0,0 +1,690 @@
+import streamlit as st
+import os
+import pandas as pd
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+import subprocess
+import numpy as np
+
+from database import check_if_indexed
+from create_index import create_initial_index as build_secure_index
+from search import search as secure_search
+from ingest_document import ingest_pdf
+import streamlit as st
+
+st.title("Aura-Mind: Your Offline AI Farming Companion")
+
+# --- Knowledge Base Management ---
+with st.sidebar:
+    st.header("Knowledge Base")
+    if st.button("Rebuild Initial Knowledge Base"):
+        with st.spinner("Deleting old base and building new one..."):
+            docs = {
+                "Healthy Maize Plant": "For a Healthy Maize Plant, ensure proper watering and sunlight. No special remedy is needed. Continue good farming practices.",
+                "Maize Phosphorus Deficiency": "Phosphorus deficiency in maize is characterized by stunted growth and purplish discoloration of leaves. To remedy this, apply a phosphorus-rich fertilizer like DAP (Di-Ammonium Phosphate) or bone meal to the soil. Follow package instructions for application rates."
+            }
+            create_initial_index(docs)
+        st.success("Initial knowledge base rebuilt!")
+    
+    st.markdown("---")
+    st.subheader("Add Your Own Knowledge")
+    uploaded_pdf = st.file_uploader("Upload a PDF document", type="pdf")
+    if uploaded_pdf is not None:
+        # Save the uploaded file temporarily to pass its path
+        temp_file_path = os.path.join(".", uploaded_pdf.name)
+        with open(temp_file_path, "wb") as f:
+            f.write(uploaded_pdf.getbuffer())
+
+        with st.spinner(f"Ingesting '{uploaded_pdf.name}'... This may take a while for large documents."):
+            ingest_pdf(temp_file_path, uploaded_pdf.name)
+        
+        st.success(f"Successfully added '{uploaded_pdf.name}' to your knowledge base!")
+        # Clean up the temporary file
+        os.remove(temp_file_path)
+
+
+# Check if the index exists. If not, offer to build it.
+if not check_if_indexed():
+    st.warning("Local knowledge base not found. Please build it from the sidebar to enable recommendations.")
+    if st.button("Build Local Knowledge Base"):
+        document_files = ["healthy_maize_remedy.txt", "maize_phosphorus_deficiency_remedy.txt", "comic_relief.txt"]
+        documents_content = []
+        for file_path in document_files:
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    documents_content.append(f.read())
+            except FileNotFoundError:
+                st.error(f"Required file not found: {file_path}")
+        
+        with st.spinner("Building secure index... This may take a moment."):
+            build_secure_index(documents_content)
+        st.success("Secure knowledge base built successfully!")
+        st.rerun()
+
+# --- Performance Tracking Setup ---
+# Initialize session state for storing performance metrics if it doesn't exist.
+if 'vlm_performance_data' not in st.session_state:
+    st.session_state.vlm_performance_data = []
+if 'tts_performance_data' not in st.session_state:
+    st.session_state.tts_performance_data = []
+
+# Audio input
+audio_file = st.audio_input("Record your audio message")
+
+# Image input: upload only (no webcam)
+uploaded_image = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
+
+# Save files if provided
+image_path = None
+
+if uploaded_image:
+    image_path = "user_image.png"
+    with open(image_path, "wb") as f:
+        f.write(uploaded_image.getbuffer())
+    st.image(uploaded_image)
+
+# Model inference
+if st.button("Run Model") and audio_path and image_path:
+    import mlx.core as mx
+    import gc
+    from mlx_vlm import load, generate
+    from mlx_vlm.prompt_utils import apply_chat_template
+
+    model_path = "./finetuned_model_for_conversion"
+    try:
+        model, processor = load(model_path)
+        config = model.config
+
+        prompt = "Classify the condition of the maize plant. Choose from Healthy Maize Plant, Maize Phosphorus Deficiency."
+        formatted_prompt = apply_chat_template(
+            processor, config, prompt,
+            num_images=1,
+        )
+
+        output = generate(
+            model,
+            processor,
+            formatted_prompt,
+            image=[image_path],
+            max_tokens=20,
+            verbose=True
+        )
+
+        # --- Capture VLM Performance ---
+        vlm_stats = {
+            "Prompt Tokens": output.prompt_tokens,
+            "Generation Tokens": output.generation_tokens,
+            "Prompt TPS": output.prompt_tps,
+            "Generation TPS": output.generation_tps,
+            "Peak Memory (GB)": output.peak_memory
+        }
+        st.session_state.vlm_performance_data.append(vlm_stats)
+
+
+        st.markdown("### Diagnosis")
+        st.write(output.text)
+
+        query = output.text.strip()
+        search_results = secure_search(query, k=3)
+
+        rag_text_for_display = None
+        tts_text = query  # Default to VLM output if no remedy is found
+
+        if search_results:
+            for result in search_results:
+                st.markdown("### Recommended Actions")
+                if result['type'] == 'text':
+                    st.markdown(result['content'])
+                    st.caption(f"Source: Text from page {result['page']}")
+                elif result['type'] == 'image':
+                    st.image(result['content'], caption=f"Source: Image from page {result['page']}")
+        else:
+            st.warning("No relevant information found in your local knowledge base.")
+
+
+        # --- Memory Cleanup ---
+        # Explicitly delete the large vision model and processor to free up
+        # memory before loading the TTS model. This is crucial on systems
+        # with limited RAM to prevent crashes.
+        with st.spinner("Clearing vision model from memory..."):
+            del model
+            del processor
+            gc.collect()
+
+        # --- Text-to-Speech Generation ---
+        st.markdown("### Generated Speech")
+        try:
+            # Get the absolute path to the project directory for robust pathing
+            project_root = os.path.dirname(os.path.abspath(__file__))
+            # In the Docker container, the TTS virtual environment is at a fixed path.
+            tts_env_python = "/app/venv_tts/bin/python"
+            tts_script = os.path.join(project_root, "tts_service", "run_tts_service.py")
+
+            # IMPORTANT: Replace with the actual path to your downloaded model
+            # Make model path absolute to avoid ambiguity in the subprocess.
+            tts_model_path = os.path.join(project_root, "orpheus-3b-pidgin-voice-v1")
+            
+            # Check if the model path exists
+            if not os.path.exists(tts_env_python):
+                st.error("TTS virtual environment not found. Please run the setup instructions in Step 3.")
+            elif not os.path.exists(tts_model_path):
+                st.error(f"TTS model not found at path: {tts_model_path}")
+                st.info("Please run `python3 download_model.py` to download the TTS model.")
+            else:
+                # Make output path absolute to ensure we know where to find it.
+                speech_output_path = os.path.join(project_root, "generated_speech.wav")
+
+                # Sanitize the text for the TTS model by replacing newlines with spaces.
+                # This prevents errors with models that can't handle multi-line input.
+                sanitized_tts_text = tts_text.replace('\n', ' ')
+
+                # --- Call the TTS script in the separate environment ---
+                command = [
+                    tts_env_python,
+                    tts_script,
+                    "--text", sanitized_tts_text,
+                    "--model-path", tts_model_path,
+                    "--output-path", speech_output_path
+                ]
+                with st.spinner("Generating speech..."):
+                    result = subprocess.run(command, capture_output=True, text=True, check=False)
+
+                # --- Capture TTS Performance ---
+                # Extract performance metrics from the TTS script's stdout.
+                tts_log = result.stdout
+                if tts_log:
+                    try:
+                        # Example of parsing: "Generation Speed: 123.45 tokens/sec"
+                        speed_line = [line for line in tts_log.split('\n') if "Generation Speed" in line]
+                        if speed_line:
+                            tts_speed = float(speed_line[0].split(':')[1].strip().split()[0])
+                            st.session_state.tts_performance_data.append({"Generation Speed (tokens/sec)": tts_speed})
+                    except (IndexError, ValueError) as e:
+                        st.warning(f"Could not parse TTS performance data: {e}")
+
+
+                if result.returncode == 0:
+                    # The TTS script appends `_000` to the filename. We need to account for that.
+                    base, ext = os.path.splitext(speech_output_path)
+                    actual_speech_path = f"{base}_000{ext}"
+
+                    # Check if the file was actually created before trying to open it.
+                    if os.path.exists(actual_speech_path):
+                        # Read the generated audio file into a bytes object
+                        # to prevent race conditions with Streamlit's file handling.
+                        with open(actual_speech_path, "rb") as audio_file:
+                            audio_bytes = audio_file.read()
+                        st.audio(audio_bytes, format="audio/wav")
+                        st.success("Speech generated successfully!")
+                        if result.stdout:
+                            with st.expander("See TTS Log"):
+                                st.code(result.stdout)
+                    else:
+                        st.error("Generated speech file not found. The TTS script might have failed silently.")
+                        st.code(f"Expected file at: {actual_speech_path}")
+                        st.code(f"TTS Service stdout:\n{result.stdout}")
+                        st.code(f"TTS Service stderr:\n{result.stderr}")
+                else:
+                    st.error("An error occurred during speech generation.")
+                    st.code(f"TTS Service Error:\n{result.stderr}")
+
+        except Exception as e:
+            st.error(f"An error occurred during speech generation: {e}")
+    except FileNotFoundError:
+        st.error(f"Error: Model not found at path '{model_path}'.")
+    except Exception as e:
+        st.error(f"An error occurred: {e}")
+else:
+    st.info("Please record audio and provide an image to run the model.")
+
+# --- Performance Dashboard ---
+st.sidebar.title("On-Device Performance Dashboard")
+
+if st.session_state.vlm_performance_data:
+    st.sidebar.markdown("### Vision & Language Model (VLM) Performance")
+    vlm_df = pd.DataFrame(st.session_state.vlm_performance_data)
+    st.sidebar.dataframe(vlm_df)
+    
+    st.sidebar.markdown("**VLM Performance Over Time**")
+    st.sidebar.line_chart(vlm_df[["Prompt TPS", "Generation TPS"]])
+    st.sidebar.line_chart(vlm_df[["Peak Memory (GB)"]])
+
+if st.session_state.tts_performance_data:
+    st.sidebar.markdown("### Text-to-Speech (TTS) Performance")
+    tts_df = pd.DataFrame(st.session_state.tts_performance_data)
+    st.sidebar.dataframe(tts_df)
+
+    st.sidebar.markdown("**TTS Performance Over Time**")
+    st.sidebar.line_chart(tts_df)
+
+if st.sidebar.button("Clear Performance Data"):
+    st.session_state.vlm_performance_data = []
+    st.session_state.tts_performance_data = []
+    st.rerun()
+
+
+--------------------------------------------------
+
+# create_index.py
+
+import numpy as np
+import faiss
+from sentence_transformers import SentenceTransformer
+import os
+
+from database import init_db, get_db_connection, INDEX_FILE, DB_FILE, delete_database_and_index
+from security import encrypt_data
+
+# Use a CLIP model that can handle both text and images
+MODEL_NAME = 'clip-ViT-B-32'
+
+def create_initial_index(documents_dict):
+    """
+    Creates an initial encrypted, persistent index from a dictionary of text documents.
+    This will delete any existing database to ensure a clean start.
+    """
+    print("Performing a clean rebuild of the knowledge base...")
+    delete_database_and_index()
+    init_db()
+
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    model = SentenceTransformer(MODEL_NAME)
+
+    all_chunks = []
+    all_embeddings = []
+
+    for name, content in documents_dict.items():
+        # Add document to documents table
+        cursor.execute("INSERT INTO documents (name) VALUES (?)", (name,))
+        doc_id = cursor.lastrowid
+
+        # For initial docs, we treat the whole content as one chunk
+        chunk_text = content
+        all_chunks.append((doc_id, 'text', encrypt_data(chunk_text.encode('utf-8')), 1))
+        
+        # Create text embedding
+        text_embedding = model.encode([chunk_text])
+        all_embeddings.append(text_embedding)
+
+    # Batch insert chunks
+    cursor.executemany(
+        "INSERT INTO chunks (doc_id, content_type, encrypted_content, page_num) VALUES (?, ?, ?, ?)",
+        all_chunks
+    )
+    conn.commit()
+    conn.close()
+
+    if not all_embeddings:
+        print("No content to index.")
+        return
+
+    # Create and save the FAISS index
+    embeddings_np = np.vstack(all_embeddings).astype('float32')
+    dimension = embeddings_np.shape[1]
+    index = faiss.IndexFlatL2(dimension)
+    index.add(embeddings_np)
+    faiss.write_index(index, INDEX_FILE)
+
+    print(f"Initial encrypted index created with {len(all_chunks)} chunks.")
+    print(f"Database: {DB_FILE}, FAISS Index: {INDEX_FILE}")
+
+
+
+if __name__ == '__main__':
+    document_files = ["healthy_maize_remedy.txt", "maize_phosphorus_deficiency_remedy.txt", "comic_relief.txt"]
+    documents_content = []
+    for file_path in document_files:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                documents_content.append(f.read())
+        except FileNotFoundError:
+            print(f"Warning: File not found, skipping: {file_path}")
+
+    create_initial_index(documents_content)
+--------------------------------------------------
+
+
+# database.py
+
+import sqlite3
+import os
+
+DB_FILE = "auramind_local.db"
+INDEX_FILE = "auramind_faiss.index"
+
+def init_db():
+    """
+    Initializes a more robust database schema for multimodal data.
+    - 'documents' table tracks the source files.
+    - 'chunks' table stores the individual encrypted text/image chunks.
+    """
+    conn = sqlite3.connect(DB_FILE)
+    cursor = conn.cursor()
+
+    # Table to track the source documents (e.g., 'healthy_maize.txt', 'user_guide.pdf')
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS documents (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL UNIQUE
+        )
+    ''')
+
+    # Table to store each chunk of content (text or image)
+    # The faiss_id will correspond to the row number in the FAISS index
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS chunks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            doc_id INTEGER,
+            content_type TEXT NOT NULL, -- 'text' or 'image'
+            encrypted_content BLOB NOT NULL,
+            page_num INTEGER,
+            FOREIGN KEY (doc_id) REFERENCES documents (id)
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def get_db_connection():
+    """Establishes a connection to the database."""
+    conn = sqlite3.connect(DB_FILE)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def check_if_indexed():
+    """Checks if the initial database and index file exist."""
+    # A basic check. A more robust check might query the db for content.
+    return os.path.exists(DB_FILE) and os.path.exists(INDEX_FILE)
+
+def delete_database_and_index():
+    """Deletes existing db and index files for a clean rebuild."""
+    if os.path.exists(DB_FILE):
+        os.remove(DB_FILE)
+        print(f"Removed old database: {DB_FILE}")
+    if os.path.exists(INDEX_FILE):
+        os.remove(INDEX_FILE)
+        print(f"Removed old index: {INDEX_FILE}")
+
+---------------------------------------------------------
+
+# database.py
+
+import sqlite3
+import os
+
+DB_FILE = "auramind_local.db"
+INDEX_FILE = "auramind_faiss.index"
+
+def init_db():
+    """
+    Initializes a more robust database schema for multimodal data.
+    - 'documents' table tracks the source files.
+    - 'chunks' table stores the individual encrypted text/image chunks.
+    """
+    conn = sqlite3.connect(DB_FILE)
+    cursor = conn.cursor()
+
+    # Table to track the source documents (e.g., 'healthy_maize.txt', 'user_guide.pdf')
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS documents (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL UNIQUE
+        )
+    ''')
+
+    # Table to store each chunk of content (text or image)
+    # The faiss_id will correspond to the row number in the FAISS index
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS chunks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            doc_id INTEGER,
+            content_type TEXT NOT NULL, -- 'text' or 'image'
+            encrypted_content BLOB NOT NULL,
+            page_num INTEGER,
+            FOREIGN KEY (doc_id) REFERENCES documents (id)
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def get_db_connection():
+    """Establishes a connection to the database."""
+    conn = sqlite3.connect(DB_FILE)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def check_if_indexed():
+    """Checks if the initial database and index file exist."""
+    # A basic check. A more robust check might query the db for content.
+    return os.path.exists(DB_FILE) and os.path.exists(INDEX_FILE)
+
+def delete_database_and_index():
+    """Deletes existing db and index files for a clean rebuild."""
+    if os.path.exists(DB_FILE):
+        os.remove(DB_FILE)
+        print(f"Removed old database: {DB_FILE}")
+    if os.path.exists(INDEX_FILE):
+        os.remove(INDEX_FILE)
+        print(f"Removed old index: {INDEX_FILE}")
+--------------------------------------------------
+
+
+# search.py
+
+import faiss
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from PIL import Image
+import io
+
+from database import get_db_connection, INDEX_FILE, check_if_indexed
+from security import decrypt_data
+
+MODEL_NAME = 'clip-ViT-B-32'
+
+def search(query, k=1):
+    """
+    Searches the multimodal FAISS index. The query can be text, and the result can be text or an image.
+    """
+    if not check_if_indexed():
+        return []
+
+    model = SentenceTransformer(MODEL_NAME)
+    index = faiss.read_index(INDEX_FILE)
+
+    # Create an embedding for the text query
+    query_embedding = model.encode([query]).astype('float32')
+    distances, indices = index.search(query_embedding, k)
+
+    results = []
+    conn = get_db_connection()
+    for i, faiss_id in enumerate(indices[0]):
+        if faiss_id != -1:
+            # The faiss_id is the row number, which corresponds to the chunk's primary key 'id'
+            sql_id = int(faiss_id) + 1
+            
+            chunk_record = conn.execute('SELECT * FROM chunks WHERE id = ?', (sql_id,)).fetchone()
+            
+            if chunk_record:
+                content_type = chunk_record['content_type']
+                decrypted_content_bytes = decrypt_data(chunk_record['encrypted_content'])
+                
+                # Prepare content based on its type
+                if content_type == 'text':
+                    content = decrypted_content_bytes.decode('utf-8')
+                elif content_type == 'image':
+                    content = Image.open(io.BytesIO(decrypted_content_bytes))
+                
+                results.append({
+                    'distance': distances[0][i],
+                    'content': content,
+                    'type': content_type,
+                    'page': chunk_record['page_num']
+                })
+    conn.close()
+    return results
+
+-----------------------------------------------------------
+
+
+
+import os
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives import padding
+from cryptography.hazmat.backends import default_backend
+import base64
+
+# In a real mobile app, this key would be securely managed by
+# the Android Keystore or iOS Keychain. For this skeleton, we'll
+# use an environment variable for demonstration.
+SECRET_KEY = os.environ.get("AURA_MIND_SECRET_KEY", "a_default_secret_key_32_bytes_!!").encode()
+
+if len(SECRET_KEY) != 32:
+    raise ValueError("SECRET_KEY must be 32 bytes long for AES-256.")
+
+def encrypt_data(data: bytes) -> bytes:
+    """Encrypts data using AES-CBC."""
+    iv = os.urandom(16)
+    padder = padding.PKCS7(algorithms.AES.block_size).padder()
+    padded_data = padder.update(data) + padder.finalize()
+    
+    cipher = Cipher(algorithms.AES(SECRET_KEY), modes.CBC(iv), backend=default_backend())
+    encryptor = cipher.encryptor()
+    encrypted_data = encryptor.update(padded_data) + encryptor.finalize()
+    return iv + encrypted_data
+
+def decrypt_data(encrypted_data_with_iv: bytes) -> bytes:
+    """Decrypts data using AES-CBC."""
+    iv = encrypted_data_with_iv[:16]
+    encrypted_data = encrypted_data_with_iv[16:]
+    
+    cipher = Cipher(algorithms.AES(SECRET_KEY), modes.CBC(iv), backend=default_backend())
+    decryptor = cipher.decryptor()
+    padded_data = decryptor.update(encrypted_data) + decryptor.finalize()
+    
+    unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
+    data = unpadder.update(padded_data) + unpadder.finalize()
+    return data
+
+--------------------------------    ------------------
+# ingest_document.py
+
+import faiss
+from sentence_transformers import SentenceTransformer
+import fitz  # PyMuPDF
+from PIL import Image
+import io
+import numpy as np
+import os
+
+from database import get_db_connection, INDEX_FILE
+from security import encrypt_data
+
+MODEL_NAME = 'clip-ViT-B-32'
+
+def ingest_pdf(file_path, file_name):
+    """Parses a PDF, encrypts its content (text+images), and adds it to the database and FAISS index."""
+    print(f"Starting ingestion for: {file_name}")
+    model = SentenceTransformer(MODEL_NAME)
+    conn = get_db_connection()
+    cursor = conn.cursor()
+
+    # Add document to documents table, or get its ID if it exists
+    try:
+        cursor.execute("INSERT INTO documents (name) VALUES (?)", (file_name,))
+        doc_id = cursor.lastrowid
+    except conn.IntegrityError:
+        print("Document already exists in DB. Skipping doc table insert.")
+        doc_id = cursor.execute("SELECT id FROM documents WHERE name=?", (file_name,)).fetchone()['id']
+
+    doc = fitz.open(file_path)
+    new_embeddings = []
+    
+    # Load existing FAISS index or create a new one
+    if os.path.exists(INDEX_FILE):
+        index = faiss.read_index(INDEX_FILE)
+    else:
+        # Get dimension from the model if index is new
+        dimension = model.encode(["test"]).shape[1]
+        index = faiss.IndexFlatL2(dimension)
+
+    for page_num, page in enumerate(doc):
+        # 1. Process Text
+        text = page.get_text()
+        if text.strip():
+            encrypted_text = encrypt_data(text.encode('utf-8'))
+            cursor.execute(
+                "INSERT INTO chunks (doc_id, content_type, encrypted_content, page_num) VALUES (?, ?, ?, ?)",
+                (doc_id, 'text', encrypted_text, page_num + 1)
+            )
+            text_embedding = model.encode([text])
+            new_embeddings.append(text_embedding)
+
+        # 2. Process Images
+        image_list = page.get_images(full=True)
+        for img_index, img in enumerate(image_list):
+            xref = img[0]
+            base_image = doc.extract_image(xref)
+            image_bytes = base_image["image"]
+            
+            encrypted_image = encrypt_data(image_bytes)
+            cursor.execute(
+                "INSERT INTO chunks (doc_id, content_type, encrypted_content, page_num) VALUES (?, ?, ?, ?)",
+                (doc_id, 'image', encrypted_image, page_num + 1)
+            )
+            pil_image = Image.open(io.BytesIO(image_bytes))
+            image_embedding = model.encode(pil_image)
+            new_embeddings.append(image_embedding.reshape(1, -1))
+
+    conn.commit()
+    conn.close()
+
+    if new_embeddings:
+        # Add new embeddings to the FAISS index
+        embeddings_np = np.vstack(new_embeddings).astype('float32')
+        index.add(embeddings_np)
+        faiss.write_index(index, INDEX_FILE)
+        print(f"Successfully ingested {file_name} and added {len(new_embeddings)} new chunks to the knowledge base.")
+    else:
+        print(f"No new content found to ingest in {file_name}.")
+
+
+
+--------------------------------------------------------
+maize_phosphorus_deficiency_remedy.txt
+
+"How You Fit Solve Phosphorus Problem for Your Corn (Maize)"
+"If your corn leaves de turn purple or dark green, especially when di plant still small, e fit be say phosphorus no reach am. Phosphorus be like power food for di plant root and for making seed."
+"Wetin You Go Do Sharp Sharp (Short-Term Solution)"
+"Bone Meal: Go market, buy bone meal. Na ground-up animal bone and e full with phosphorus. Sprinkle small quantity around di base of your corn plant and mix am small with di soil. No let am touch di plant stem direct."
+"Fish Fertilizer (Fish Tea): If you fit get fish head or bones, soak dem inside water for some days. Di water go turn to strong fertilizer. Mix one cup of this fish tea with ten cups of plain water, and use am water your corn one time in a week."
+"Wetin You Go Do for Future Planting (Long-Term Solution)"
+"Chicken Manure (Fowl Yansh): Before you plant next time, make sure you add well-decayed chicken manure to your soil. Fowl yansh get plenty phosphorus. No use fresh one, e dey too strong and e go burn your plant. Make sure e don dry well well."
+"Plant Legumes: Plant beans (cowpea) or groundnut for di land before you plant corn again. Dis plants de help make di soil rich and e go help free up phosphorus for di next crop."
+"Check Your Soil pH: Sometimes, di phosphorus dey inside di soil but di soil too strong (acidic) for di plant to chop am. You fit add small wood ash to di soil before you plant. E go help balance di soil and make di phosphorus available for di corn."
+"Remember, small small na im dem de take chop hot soup. Start with small quantity of fertilizer, watch your plant, and add more if you need am."
+
+----------------------------------------------------
+
+healthy_maize_remedy.txt
+
+"So your farm don produce beta corn? Oya, make we see different ways you fit enjoy am with your family. Corn no be for roasting alone!"
+"Better Ways to Enjoy Your Healthy Corn (Maize)"
+"Agbado (Roasted Corn) and Ube (Pear):Dis one na classic street food for Naija. Just roast your fresh corn over charcoal fire until e brown small. Eat am with soft pear wey you don roast small or boil inside hot water. Di sweetness of di corn and di creamy pear na match made in heaven!"
+"Boiled Corn: Simple and sweet. Just remove di husk (di green leaf), put di corn inside pot with water and small salt. Cook am until di corn soft. You fit chop am like dat or with coconut. E dey very sweet and filling."
+"Pap (Akamu or Ogi): For dis one, you go need dry corn. Soak di corn for water for like two or three days until e soft. Grind am well well into a paste. Use clean cloth or sieve to separate di smooth paste from di chaff (di rough part). Allow di smooth paste to siddon and ferment small for one day. To prepare am, just mix small of di paste with cold water, then pour hot water on top and stir fast fast until e thick. Enjoy am with akara, moin moin, or milk and sugar."
+"Tuwo Masara:This na like swallow for northern people. You go grind dry corn into a fine powder (corn flour). Put water for pot and make e boil. Mix small of di corn flour with cold water to make a paste, then pour am inside di boiling water and stir well. As e de thick, de add more of di dry flour small small and de turn am with turning stick until e strong like semo or eba. Serve am with any soup like Miyan Kuka or Miyan Taushe."
+"Egusi and Corn Soup:You fit add fresh corn to your egusi soup! When you don fry your egusi finish and add your meat and fish, just cut fresh corn from di cob and pour am inside di soup. Allow am to cook for like 10-15 minutes. Di sweetness of di corn go make your egusi soup taste different and special."
+----------------------------------------------------
+
+comic_relief.txt
+
+"Wetin My Eye See So?"
+"Ah! Oga/Madam farmer, this one pass my power o. I don look this picture soteh my eye dey turn. E be like say this thing no be corn at all o, or maybe na some new style of corn wey dem just invent for another planet. Abeg, you fit try another picture? Make my brain no go knock before you come back. No vex!"
+
+---------------------------------------------------
+
+
+
+
+