Delete RAG

RAG/.gradio/certificate.pem

@@ -1,31 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
-TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
-cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
-WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
-ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
-MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
-h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
-0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
-A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
-T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
-B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
-B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
-KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
-OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
-jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
-qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
-rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
-HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
-hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
-ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
-3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
-NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
-ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
-TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
-jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
-oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
-4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
-mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
-emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
------END CERTIFICATE-----

RAG/.ipynb_checkpoints/New try-checkpoint.ipynb

@@ -1,692 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "e549bafd-78b1-4a83-80b4-2cb597efff79",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import json\n",
-    "from google.oauth2 import service_account\n",
-    "from googleapiclient.discovery import build\n",
-    "from googleapiclient.http import MediaIoBaseDownload\n",
-    "import openai\n",
-    "from dotenv import load_dotenv\n",
-    "import io"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "id": "04361235-7896-4439-9d04-1400e043528b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 35,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "load_dotenv()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "id": "7622a0e4-64a6-4848-b588-bd65d56c55e0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from openai import OpenAI\n",
-    "openai.api_key = os.getenv('OPENAI_API_KEY')\n",
-    "openai = OpenAI(api_key = openai.api_key)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "id": "b3bcbada-6a72-4cc8-a166-d2e596cd1fc4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "service_account_file_path = os.getenv(\"GOOGLE_SERVICE_ACCOUNT_FILE\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "81c59a6d-0831-4bff-b3fc-fbe3d4cc1e31",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "openai activated\n",
-      "service_account_file_path not activated\n"
-     ]
-    }
-   ],
-   "source": [
-    "#troubleshoot\n",
-    "if openai is None:\n",
-    "    print(\"openai not activated\")\n",
-    "else: \n",
-    "    print (\"openai activated\")\n",
-    "\n",
-    "if service_account_file_path is None:\n",
-    "    print(\"service_account_file_path not activated\")\n",
-    "else: \n",
-    "    print (\"service_account_file_path activated\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a70f32aa-9e43-4175-8cca-d6af723aef91",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "0efe325d-badd-4533-affe-47d572ef128e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class GPTDriveIntegration:\n",
-    "    def __init__(self):\n",
-    "        # Initialize Google Drive API\n",
-    "        self.credentials = service_account.Credentials.from_service_account_file(\n",
-    "            os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE'),\n",
-    "            scopes=['https://www.googleapis.com/auth/drive.readonly']\n",
-    "        )\n",
-    "        self.drive_service = build('drive', 'v3', credentials=self.credentials)\n",
-    "        \n",
-    "        # Initialize OpenAI\n",
-    "        openai.api_key = os.getenv('OPENAI_API_KEY')\n",
-    "    \n",
-    "    def search_files(self, query, file_types=None):\n",
-    "        \"\"\"Search for files in Google Drive\"\"\"\n",
-    "        search_query = f\"name contains '{query}'\"\n",
-    "        \n",
-    "        if file_types:\n",
-    "            type_queries = []\n",
-    "            for file_type in file_types:\n",
-    "                if file_type.lower() == 'pdf':\n",
-    "                    type_queries.append(\"mimeType='application/pdf'\")\n",
-    "                elif file_type.lower() in ['doc', 'docx']:\n",
-    "                    type_queries.append(\"mimeType contains 'document'\")\n",
-    "                elif file_type.lower() in ['xls', 'xlsx']:\n",
-    "                    type_queries.append(\"mimeType contains 'spreadsheet'\")\n",
-    "            \n",
-    "            if type_queries:\n",
-    "                search_query += f\" and ({' or '.join(type_queries)})\"\n",
-    "        \n",
-    "        results = self.drive_service.files().list(\n",
-    "            q=search_query,\n",
-    "            fields=\"files(id, name, mimeType, size)\"\n",
-    "        ).execute()\n",
-    "        \n",
-    "        return results.get('files', [])\n",
-    "    \n",
-    "    def get_file_content(self, file_id, mime_type):\n",
-    "        \"\"\"Download and extract text content from file\"\"\"\n",
-    "        try:\n",
-    "            if 'text' in mime_type or 'document' in mime_type:\n",
-    "                # For Google Docs, export as plain text\n",
-    "                if 'document' in mime_type:\n",
-    "                    request = self.drive_service.files().export_media(\n",
-    "                        fileId=file_id, mimeType='text/plain'\n",
-    "                    )\n",
-    "                else:\n",
-    "                    request = self.drive_service.files().get_media(fileId=file_id)\n",
-    "                \n",
-    "                file_content = io.BytesIO()\n",
-    "                downloader = MediaIoBaseDownload(file_content, request)\n",
-    "                done = False\n",
-    "                while done is False:\n",
-    "                    status, done = downloader.next_chunk()\n",
-    "                \n",
-    "                return file_content.getvalue().decode('utf-8')\n",
-    "            \n",
-    "            elif 'spreadsheet' in mime_type:\n",
-    "                # For Google Sheets, export as CSV\n",
-    "                request = self.drive_service.files().export_media(\n",
-    "                    fileId=file_id, mimeType='text/csv'\n",
-    "                )\n",
-    "                file_content = io.BytesIO()\n",
-    "                downloader = MediaIoBaseDownload(file_content, request)\n",
-    "                done = False\n",
-    "                while done is False:\n",
-    "                    status, done = downloader.next_chunk()\n",
-    "                \n",
-    "                return file_content.getvalue().decode('utf-8')\n",
-    "            \n",
-    "            else:\n",
-    "                return \"File type not supported for text extraction\"\n",
-    "                \n",
-    "        except Exception as e:\n",
-    "            return f\"Error reading file: {str(e)}\"\n",
-    "    \n",
-    "    def query_gpt_with_context(self, user_query, file_contents):\n",
-    "        \"\"\"Send query to GPT with file context\"\"\"\n",
-    "        context = \"\\n\\n\".join([\n",
-    "            f\"File: {content['name']}\\nContent: {content['text'][:2000]}...\"\n",
-    "            for content in file_contents\n",
-    "        ])\n",
-    "        \n",
-    "        messages = [\n",
-    "            {\n",
-    "                \"role\": \"system\", \n",
-    "                \"content\": \"\"\"\n",
-    "                You are an AI assistant that can analyze documents from Google Drive. \n",
-    "                Use the provided file contents to answer user questions.\"\"\"\n",
-    "            },\n",
-    "            {\n",
-    "                \"role\": \"user\", \n",
-    "                \"content\": f\"Context from Google Drive files:\\n{context}\\n\\nUser Question: {user_query}\"\n",
-    "            }\n",
-    "        ]\n",
-    "        \n",
-    "        response = openai.ChatCompletion.create(\n",
-    "            model=\"gpt-4o-mini\",\n",
-    "            messages=messages,\n",
-    "            max_tokens=1000\n",
-    "        )\n",
-    "        \n",
-    "        return response.choices[0].message.content\n",
-    "    \n",
-    "    def process_query(self, user_query, search_terms=None):\n",
-    "        \"\"\"Main function to process user queries\"\"\"\n",
-    "        # Extract search terms from query if not provided\n",
-    "        if not search_terms:\n",
-    "            search_terms = user_query.split()[:3]  # Simple extraction\n",
-    "        \n",
-    "        # Search for relevant files\n",
-    "        files = []\n",
-    "        for term in search_terms:\n",
-    "            files.extend(self.search_files(term))\n",
-    "        \n",
-    "        # Remove duplicates\n",
-    "        unique_files = {f['id']: f for f in files}.values()\n",
-    "        \n",
-    "        # Get content from top 3 most relevant files\n",
-    "        file_contents = []\n",
-    "        for file in list(unique_files)[:3]:\n",
-    "            content = self.get_file_content(file['id'], file['mimeType'])\n",
-    "            file_contents.append({\n",
-    "                'name': file['name'],\n",
-    "                'text': content\n",
-    "            })\n",
-    "        \n",
-    "        # Query GPT with context\n",
-    "        if file_contents:\n",
-    "            response = self.query_gpt_with_context(user_query, file_contents)\n",
-    "            return {\n",
-    "                'answer': response,\n",
-    "                'sources': [f['name'] for f in file_contents]\n",
-    "            }\n",
-    "        else:\n",
-    "            return {\n",
-    "                'answer': \"No relevant files found in your Google Drive.\",\n",
-    "                'sources': []\n",
-    "            }"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3c2c1ccf-9ade-482d-a170-978e97bc1c08",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if __name__ == \"__main__\":\n",
-    "    integration = GPTDriveIntegration()\n",
-    "    \n",
-    "    # Test query\n",
-    "    result = integration.process_query(\n",
-    "        \"What are the main points from my meeting notes?\",\n",
-    "        search_terms=[\"meeting\", \"notes\"]\n",
-    "    )\n",
-    "    \n",
-    "    print(\"Answer:\", result['answer'])\n",
-    "    print(\"Sources:\", result['sources'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "120e7c93-b38a-4c89-8e76-5b0170d22548",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "GOOGLE_SERVICE_ACCOUNT_FILE= r\"C:\\Users\\Uche Buzz\\myprojects\\RAG\\rag-system-463320-f292991d0516.json\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "634b9787-d493-46e5-8114-0851c6172ed6",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "❌ GOOGLE_SERVICE_ACCOUNT_FILE environment variable not set\n",
-      "💡 Add this to your .env file:\n",
-      "GOOGLE_SERVICE_ACCOUNT_FILE=path/to/your/service-account-key.json\n"
-     ]
-    }
-   ],
-   "source": [
-    "import json\n",
-    "from google.auth.exceptions import RefreshError\n",
-    "from googleapiclient.errors import HttpError\n",
-    "\n",
-    "class GPTDriveTroubleshooter:\n",
-    "    def __init__(self, service_account_file_path):\n",
-    "        self.service_account_file = service_account_file_path\n",
-    "        self.credentials = None\n",
-    "        self.drive_service = None\n",
-    "        \n",
-    "    def run_full_diagnostic(self):\n",
-    "        \"\"\"Run complete diagnostic check\"\"\"\n",
-    "        print(\"🔍 Starting Google Drive API Diagnostic...\")\n",
-    "        print(\"=\" * 50)\n",
-    "        \n",
-    "        # Step 1: Check service account file\n",
-    "        if not self.check_service_account_file():\n",
-    "            return False\n",
-    "            \n",
-    "        # Step 2: Check credentials\n",
-    "        if not self.check_credentials():\n",
-    "            return False\n",
-    "            \n",
-    "        # Step 3: Test API connection\n",
-    "        if not self.test_api_connection():\n",
-    "            return False\n",
-    "            \n",
-    "        # Step 4: Check permissions\n",
-    "        if not self.check_basic_permissions():\n",
-    "            return False\n",
-    "            \n",
-    "        # Step 5: Test folder access\n",
-    "        self.test_folder_access()\n",
-    "        \n",
-    "        print(\"\\n✅ All basic checks passed!\")\n",
-    "        return True\n",
-    "    \n",
-    "    def check_service_account_file(self):\n",
-    "        \"\"\"Check if service account file exists and is valid\"\"\"\n",
-    "        print(\"\\n1️⃣ Checking service account file...\")\n",
-    "        \n",
-    "        if not os.path.exists(self.service_account_file):\n",
-    "            print(f\"❌ Service account file not found: {self.service_account_file}\")\n",
-    "            print(\"💡 Make sure you've downloaded the JSON key file from Google Cloud Console\")\n",
-    "            return False\n",
-    "        \n",
-    "        try:\n",
-    "            with open(self.service_account_file, 'r') as f:\n",
-    "                service_account_info = json.load(f)\n",
-    "            \n",
-    "            required_fields = ['type', 'project_id', 'private_key_id', 'private_key', 'client_email']\n",
-    "            missing_fields = [field for field in required_fields if field not in service_account_info]\n",
-    "            \n",
-    "            if missing_fields:\n",
-    "                print(f\"❌ Service account file missing required fields: {missing_fields}\")\n",
-    "                return False\n",
-    "            \n",
-    "            print(f\"✅ Service account file is valid\")\n",
-    "            print(f\"   📧 Service account email: {service_account_info['client_email']}\")\n",
-    "            print(f\"   🏗️ Project ID: {service_account_info['project_id']}\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except json.JSONDecodeError:\n",
-    "            print(\"❌ Service account file is not valid JSON\")\n",
-    "            return False\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error reading service account file: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def check_credentials(self):\n",
-    "        \"\"\"Check if credentials can be created\"\"\"\n",
-    "        print(\"\\n2️⃣ Checking credentials...\")\n",
-    "        \n",
-    "        try:\n",
-    "            self.credentials = service_account.Credentials.from_service_account_file(\n",
-    "                self.service_account_file,\n",
-    "                scopes=['https://www.googleapis.com/auth/drive.readonly']\n",
-    "            )\n",
-    "            print(\"✅ Credentials created successfully\")\n",
-    "            return True\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Failed to create credentials: {e}\")\n",
-    "            print(\"💡 Check if your service account key file is corrupted\")\n",
-    "            return False\n",
-    "    \n",
-    "    def test_api_connection(self):\n",
-    "        \"\"\"Test basic API connection\"\"\"\n",
-    "        print(\"\\n3️⃣ Testing API connection...\")\n",
-    "        \n",
-    "        try:\n",
-    "            self.drive_service = build('drive', 'v3', credentials=self.credentials)\n",
-    "            \n",
-    "            # Try a simple API call\n",
-    "            about = self.drive_service.about().get(fields=\"user, storageQuota\").execute()\n",
-    "            print(\"✅ Successfully connected to Google Drive API\")\n",
-    "            print(f\"   👤 Connected as: {about.get('user', {}).get('emailAddress', 'Unknown')}\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except HttpError as e:\n",
-    "            print(f\"❌ HTTP Error connecting to API: {e}\")\n",
-    "            if e.resp.status == 403:\n",
-    "                print(\"💡 This is likely a permissions issue - check if Drive API is enabled\")\n",
-    "            return False\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Failed to connect to API: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def check_basic_permissions(self):\n",
-    "        \"\"\"Check basic file listing permissions\"\"\"\n",
-    "        print(\"\\n4️⃣ Checking basic permissions...\")\n",
-    "        \n",
-    "        try:\n",
-    "            # Try to list files (this should work with readonly access)\n",
-    "            results = self.drive_service.files().list(\n",
-    "                pageSize=1,\n",
-    "                fields=\"files(id, name)\"\n",
-    "            ).execute()\n",
-    "            \n",
-    "            files = results.get('files', [])\n",
-    "            print(f\"✅ Can access Drive API - found {len(files)} files in test query\")\n",
-    "            \n",
-    "            if len(files) == 0:\n",
-    "                print(\"⚠️ No files found - this might mean:\")\n",
-    "                print(\"   • Service account has no shared files\")\n",
-    "                print(\"   • No files are shared with the service account\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except HttpError as e:\n",
-    "            print(f\"❌ Permission error: {e}\")\n",
-    "            if e.resp.status == 403:\n",
-    "                print(\"💡 Common causes:\")\n",
-    "                print(\"   • Google Drive API not enabled in Google Cloud Console\")\n",
-    "                print(\"   • Service account doesn't have proper permissions\")\n",
-    "            return False\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error checking permissions: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def test_folder_access(self, folder_name=\"Blue berry\"):\n",
-    "        \"\"\"Test access to specific folder\"\"\"\n",
-    "        print(f\"\\n5️⃣ Testing access to '{folder_name}' folder...\")\n",
-    "        \n",
-    "        try:\n",
-    "            # Search for the folder\n",
-    "            query = f\"name='{folder_name}' and mimeType='application/vnd.google-apps.folder' and trashed=false\"\n",
-    "            results = self.drive_service.files().list(\n",
-    "                q=query,\n",
-    "                fields=\"files(id, name, owners, permissions)\"\n",
-    "            ).execute()\n",
-    "            \n",
-    "            folders = results.get('files', [])\n",
-    "            \n",
-    "            if not folders:\n",
-    "                print(f\"❌ Folder '{folder_name}' not found or not accessible\")\n",
-    "                print(\"💡 Possible solutions:\")\n",
-    "                print(\"   • Make sure the folder exists in Google Drive\")\n",
-    "                print(\"   • Share the folder with your service account email\")\n",
-    "                print(\"   • Check folder name spelling (case sensitive)\")\n",
-    "                return False\n",
-    "            \n",
-    "            folder = folders[0]\n",
-    "            print(f\"✅ Found folder '{folder_name}'\")\n",
-    "            print(f\"   📁 Folder ID: {folder['id']}\")\n",
-    "            \n",
-    "            # Test listing files in the folder\n",
-    "            files_in_folder = self.drive_service.files().list(\n",
-    "                q=f\"'{folder['id']}' in parents and trashed=false\",\n",
-    "                fields=\"files(id, name, mimeType)\"\n",
-    "            ).execute()\n",
-    "            \n",
-    "            files = files_in_folder.get('files', [])\n",
-    "            print(f\"   📄 Contains {len(files)} files\")\n",
-    "            \n",
-    "            if files:\n",
-    "                print(\"   📝 Sample files:\")\n",
-    "                for file in files[:3]:  # Show first 3 files\n",
-    "                    print(f\"      • {file['name']} ({file['mimeType']})\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except HttpError as e:\n",
-    "            print(f\"❌ HTTP Error accessing folder: {e}\")\n",
-    "            return False\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error accessing folder: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def check_file_permissions(self, file_id):\n",
-    "        \"\"\"Check permissions for a specific file\"\"\"\n",
-    "        print(f\"\\n🔍 Checking permissions for file ID: {file_id}\")\n",
-    "        \n",
-    "        try:\n",
-    "            file_info = self.drive_service.files().get(\n",
-    "                fileId=file_id,\n",
-    "                fields=\"id, name, mimeType, owners, permissions, capabilities\"\n",
-    "            ).execute()\n",
-    "            \n",
-    "            print(f\"✅ File: {file_info['name']}\")\n",
-    "            print(f\"   🔗 Type: {file_info['mimeType']}\")\n",
-    "            print(f\"   👤 Owner: {file_info.get('owners', [{}])[0].get('emailAddress', 'Unknown')}\")\n",
-    "            \n",
-    "            capabilities = file_info.get('capabilities', {})\n",
-    "            print(f\"   📖 Can read: {capabilities.get('canDownload', False)}\")\n",
-    "            print(f\"   📤 Can export: {capabilities.get('canExport', False)}\")\n",
-    "            \n",
-    "        except HttpError as e:\n",
-    "            print(f\"❌ Cannot access file: {e}\")\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error: {e}\")\n",
-    "    \n",
-    "    def get_sharing_instructions(self):\n",
-    "        \"\"\"Provide step-by-step sharing instructions\"\"\"\n",
-    "        print(\"\\n📋 HOW TO SHARE FOLDER WITH SERVICE ACCOUNT:\")\n",
-    "        print(\"=\" * 50)\n",
-    "        \n",
-    "        if self.credentials:\n",
-    "            service_email = self.credentials.service_account_email\n",
-    "            print(f\"1. Copy this service account email: {service_email}\")\n",
-    "        else:\n",
-    "            print(\"1. Find your service account email in the JSON key file (client_email field)\")\n",
-    "        \n",
-    "        print(\"2. Open Google Drive in your browser\")\n",
-    "        print(\"3. Right-click on your 'Blue berry' folder\")\n",
-    "        print(\"4. Select 'Share'\")\n",
-    "        print(\"5. Paste the service account email\")\n",
-    "        print(\"6. Set permission to 'Viewer' or 'Editor'\")\n",
-    "        print(\"7. Click 'Send' (you can uncheck 'Notify people')\")\n",
-    "        print(\"8. Wait a few minutes for permissions to propagate\")\n",
-    "        \n",
-    "    def run_connection_test(self):\n",
-    "        \"\"\"Quick connection test\"\"\"\n",
-    "        print(\"🚀 Quick Connection Test\")\n",
-    "        print(\"-\" * 30)\n",
-    "        \n",
-    "        try:\n",
-    "            self.credentials = service_account.Credentials.from_service_account_file(\n",
-    "                self.service_account_file,\n",
-    "                scopes=['https://www.googleapis.com/auth/drive.readonly']\n",
-    "            )\n",
-    "            \n",
-    "            service = build('drive', 'v3', credentials=self.credentials)\n",
-    "            \n",
-    "            # Test basic query\n",
-    "            results = service.files().list(pageSize=5).execute()\n",
-    "            files = results.get('files', [])\n",
-    "            \n",
-    "            print(f\"✅ Connected! Found {len(files)} accessible files\")\n",
-    "            print(f\"📧 Service account: {self.credentials.service_account_email}\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Connection failed: {e}\")\n",
-    "            return False\n",
-    "\n",
-    "# Usage Examples\n",
-    "def troubleshoot_drive_access():\n",
-    "    \"\"\"Main troubleshooting function\"\"\"\n",
-    "    service_account_file = os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE')\n",
-    "    \n",
-    "    if not service_account_file:\n",
-    "        print(\"❌ GOOGLE_SERVICE_ACCOUNT_FILE environment variable not set\")\n",
-    "        print(\"💡 Add this to your .env file:\")\n",
-    "        print(\"GOOGLE_SERVICE_ACCOUNT_FILE=path/to/your/service-account-key.json\")\n",
-    "        return\n",
-    "    \n",
-    "    troubleshooter = GPTDriveTroubleshooter(service_account_file)\n",
-    "    \n",
-    "    # Run full diagnostic\n",
-    "    success = troubleshooter.run_full_diagnostic()\n",
-    "    \n",
-    "    if not success:\n",
-    "        print(\"\\n\" + \"=\"*50)\n",
-    "        troubleshooter.get_sharing_instructions()\n",
-    "    \n",
-    "    return success\n",
-    "\n",
-    "# Quick test function\n",
-    "def quick_test():\n",
-    "    \"\"\"Quick test to verify everything works\"\"\"\n",
-    "    service_account_file = os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE')\n",
-    "    troubleshooter = GPTDriveTroubleshooter(service_account_file)\n",
-    "    return troubleshooter.run_connection_test()\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    # Uncomment the test you want to run:\n",
-    "    \n",
-    "    # Full diagnostic (recommended for first-time setup)\n",
-    "    troubleshoot_drive_access()\n",
-    "    \n",
-    "    # Quick test (for regular checks)\n",
-    "    # quick_test()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "6b336789-d402-455d-a631-26e987d79ed6",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'GPTDriveTroubleshooter' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
-      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[13]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m troubleshooter = \u001b[43mGPTDriveTroubleshooter\u001b[49m(GOOGLE_SERVICE_ACCOUNT_FILE)\n\u001b[32m      2\u001b[39m troubleshooter.test_folder_access(\u001b[33m\"\u001b[39m\u001b[33mBlue berry\u001b[39m\u001b[33m\"\u001b[39m)\n",
-      "\u001b[31mNameError\u001b[39m: name 'GPTDriveTroubleshooter' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "troubleshooter = GPTDriveTroubleshooter(GOOGLE_SERVICE_ACCOUNT_FILE)\n",
-    "troubleshooter.test_folder_access(\"Blue berry\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "e2786c67-215e-46b0-b3ca-2c3176bd8971",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "expected str, bytes or os.PathLike object, not NoneType",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
-      "\u001b[31mTypeError\u001b[39m                                 Traceback (most recent call last)",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 23\u001b[39m\n\u001b[32m     20\u001b[39m         \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mMake sure you\u001b[39m\u001b[33m'\u001b[39m\u001b[33mve shared the folder with your service account\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m     22\u001b[39m \u001b[38;5;66;03m# Run this test first\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m23\u001b[39m \u001b[43mtest_folder_access\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 3\u001b[39m, in \u001b[36mtest_folder_access\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m      2\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mtest_folder_access\u001b[39m():\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m     integration = \u001b[43mGPTDriveIntegration\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m      4\u001b[39m     folder_id = integration.find_folder_by_name(\u001b[33m\"\u001b[39m\u001b[33mBlue berry\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m      5\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m folder_id:\n",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 4\u001b[39m, in \u001b[36mGPTDriveIntegration.__init__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m      2\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m      3\u001b[39m     \u001b[38;5;66;03m# Initialize Google Drive API\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m     \u001b[38;5;28mself\u001b[39m.credentials = \u001b[43mservice_account\u001b[49m\u001b[43m.\u001b[49m\u001b[43mCredentials\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfrom_service_account_file\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m      5\u001b[39m \u001b[43m        \u001b[49m\u001b[43mos\u001b[49m\u001b[43m.\u001b[49m\u001b[43mgetenv\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mGOOGLE_SERVICE_ACCOUNT_FILE\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m      6\u001b[39m \u001b[43m        \u001b[49m\u001b[43mscopes\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mhttps://www.googleapis.com/auth/drive.readonly\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[32m      7\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m      8\u001b[39m     \u001b[38;5;28mself\u001b[39m.drive_service = build(\u001b[33m'\u001b[39m\u001b[33mdrive\u001b[39m\u001b[33m'\u001b[39m, \u001b[33m'\u001b[39m\u001b[33mv3\u001b[39m\u001b[33m'\u001b[39m, credentials=\u001b[38;5;28mself\u001b[39m.credentials)\n\u001b[32m     10\u001b[39m     \u001b[38;5;66;03m# Initialize OpenAI\u001b[39;00m\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~\\anaconda3\\envs\\RAG\\Lib\\site-packages\\google\\oauth2\\service_account.py:260\u001b[39m, in \u001b[36mCredentials.from_service_account_file\u001b[39m\u001b[34m(cls, filename, **kwargs)\u001b[39m\n\u001b[32m    248\u001b[39m \u001b[38;5;129m@classmethod\u001b[39m\n\u001b[32m    249\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mfrom_service_account_file\u001b[39m(\u001b[38;5;28mcls\u001b[39m, filename, **kwargs):\n\u001b[32m    250\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"Creates a Credentials instance from a service account json file.\u001b[39;00m\n\u001b[32m    251\u001b[39m \n\u001b[32m    252\u001b[39m \u001b[33;03m    Args:\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    258\u001b[39m \u001b[33;03m            credentials.\u001b[39;00m\n\u001b[32m    259\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m260\u001b[39m     info, signer = \u001b[43m_service_account_info\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfrom_filename\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    261\u001b[39m \u001b[43m        \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrequire\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mclient_email\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mtoken_uri\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[32m    262\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    263\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m._from_signer_and_info(signer, info, **kwargs)\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~\\anaconda3\\envs\\RAG\\Lib\\site-packages\\google\\auth\\_service_account_info.py:78\u001b[39m, in \u001b[36mfrom_filename\u001b[39m\u001b[34m(filename, require, use_rsa_signer)\u001b[39m\n\u001b[32m     64\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mfrom_filename\u001b[39m(filename, require=\u001b[38;5;28;01mNone\u001b[39;00m, use_rsa_signer=\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[32m     65\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"Reads a Google service account JSON file and returns its parsed info.\u001b[39;00m\n\u001b[32m     66\u001b[39m \n\u001b[32m     67\u001b[39m \u001b[33;03m    Args:\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m     76\u001b[39m \u001b[33;03m            info and a signer instance.\u001b[39;00m\n\u001b[32m     77\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m78\u001b[39m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43mio\u001b[49m\u001b[43m.\u001b[49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mr\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mutf-8\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m json_file:\n\u001b[32m     79\u001b[39m         data = json.load(json_file)\n\u001b[32m     80\u001b[39m         \u001b[38;5;28;01mreturn\u001b[39;00m data, from_dict(data, require=require, use_rsa_signer=use_rsa_signer)\n",
-      "\u001b[31mTypeError\u001b[39m: expected str, bytes or os.PathLike object, not NoneType"
-     ]
-    }
-   ],
-   "source": [
-    "# Add this test function to verify access\n",
-    "def test_folder_access():\n",
-    "    integration = GPTDriveIntegration()\n",
-    "    folder_id = integration.find_folder_by_name(\"Blue berry\")\n",
-    "    if folder_id:\n",
-    "        print(\"✅ Successfully found 'Blue berry' folder!\")\n",
-    "        \n",
-    "        # List files in the folder\n",
-    "        results = integration.drive_service.files().list(\n",
-    "            q=f\"'{folder_id}' in parents and trashed=false\",\n",
-    "            fields=\"files(id, name, mimeType)\"\n",
-    "        ).execute()\n",
-    "        \n",
-    "        files = results.get('files', [])\n",
-    "        print(f\"Found {len(files)} files in the folder:\")\n",
-    "        for file in files[:5]:  # Show first 5 files\n",
-    "            print(f\"  - {file['name']} ({file['mimeType']})\")\n",
-    "    else:\n",
-    "        print(\"❌ Could not access 'Blue berry' folder\")\n",
-    "        print(\"Make sure you've shared the folder with your service account\")\n",
-    "\n",
-    "# Run this test first\n",
-    "test_folder_access()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c3dede9f-5e01-436d-a7b7-905e1646baf9",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.13.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

RAG/.ipynb_checkpoints/RAG-1-checkpoint.ipynb

@@ -1,1404 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "e549bafd-78b1-4a83-80b4-2cb597efff79",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import json\n",
-    "from google.oauth2 import service_account\n",
-    "from googleapiclient.discovery import build\n",
-    "from googleapiclient.http import MediaIoBaseDownload\n",
-    "import openai\n",
-    "from dotenv import load_dotenv, dotenv_values\n",
-    "import io"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "04361235-7896-4439-9d04-1400e043528b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "load_dotenv()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "9ae411c5-c84b-4bfd-b089-69b5c5ba70ae",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "OPENAI_API_KEY\n",
-      "ANTHROPIC_API_KEY\n",
-      "GOOGLE_SERVICE_ACCOUNT_FILE\n"
-     ]
-    }
-   ],
-   "source": [
-    "config = dotenv_values(\".env\")\n",
-    "for key in config.keys():\n",
-    "    print(key)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "7622a0e4-64a6-4848-b588-bd65d56c55e0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from openai import OpenAI\n",
-    "openai.api_key = os.getenv('OPENAI_API_KEY')\n",
-    "openai = OpenAI(api_key = openai.api_key)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "2ead7c59-1f11-478a-bb69-2928ddc38901",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Hello! How can I assist you today?\n"
-     ]
-    }
-   ],
-   "source": [
-    "response = openai.chat.completions.create(\n",
-    "    model = \"gpt-4o-mini\",\n",
-    "    messages = [\n",
-    "        {\"role\":\"system\", \"content\":\"you are a helpful assistant\"},\n",
-    "        {\"role\":\"user\", \"content\":\"hi\"}\n",
-    "    ])\n",
-    "\n",
-    "reply = response.choices[0].message.content\n",
-    "print(reply)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "b3bcbada-6a72-4cc8-a166-d2e596cd1fc4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "service_account_file_path = os.getenv(\"GOOGLE_SERVICE_ACCOUNT_FILE\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "81c59a6d-0831-4bff-b3fc-fbe3d4cc1e31",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "openai activated\n",
-      "service_account_file_path activated\n"
-     ]
-    }
-   ],
-   "source": [
-    "#troubleshoot\n",
-    "if openai is None:\n",
-    "    print(\"openai not activated\")\n",
-    "else: \n",
-    "    print (\"openai activated\")\n",
-    "\n",
-    "if service_account_file_path is None:\n",
-    "    print(\"service_account_file_path not activated\")\n",
-    "else: \n",
-    "    print (\"service_account_file_path activated\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "a70f32aa-9e43-4175-8cca-d6af723aef91",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "your credentials is C:/Users/Uche Buzz/myprojects/RAG/rag-system-463320-f292991d0516.json\n"
-     ]
-    }
-   ],
-   "source": [
-    "print (f\"your credentials is {service_account_file_path}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "0efe325d-badd-4533-affe-47d572ef128e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class GPTDriveIntegration:\n",
-    "    def __init__(self):\n",
-    "        # Initialize Google Drive API\n",
-    "        self.credentials = service_account.Credentials.from_service_account_file(\n",
-    "            os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE'),\n",
-    "            scopes=['https://www.googleapis.com/auth/drive.readonly']\n",
-    "        )\n",
-    "        self.drive_service = build('drive', 'v3', credentials=self.credentials)\n",
-    "        \n",
-    "        # Initialize OpenAI\n",
-    "        openai.api_key = os.getenv('OPENAI_API_KEY')\n",
-    "    \n",
-    "    def search_files(self, query, file_types=None):\n",
-    "        \"\"\"Search for files in Google Drive\"\"\"\n",
-    "        search_query = f\"name contains '{query}'\"\n",
-    "        \n",
-    "        if file_types:\n",
-    "            type_queries = []\n",
-    "            for file_type in file_types:\n",
-    "                if file_type.lower() == 'pdf':\n",
-    "                    type_queries.append(\"mimeType='application/pdf'\")\n",
-    "                elif file_type.lower() in ['doc', 'docx']:\n",
-    "                    type_queries.append(\"mimeType contains 'document'\")\n",
-    "                elif file_type.lower() in ['xls', 'xlsx']:\n",
-    "                    type_queries.append(\"mimeType contains 'spreadsheet'\")\n",
-    "            \n",
-    "            if type_queries:\n",
-    "                search_query += f\" and ({' or '.join(type_queries)})\"\n",
-    "        \n",
-    "        results = self.drive_service.files().list(\n",
-    "            q=search_query,\n",
-    "            fields=\"files(id, name, mimeType, size)\"\n",
-    "        ).execute()\n",
-    "        \n",
-    "        return results.get('files', [])\n",
-    "    \n",
-    "    def get_file_content(self, file_id, mime_type):\n",
-    "        \"\"\"Download and extract text content from file\"\"\"\n",
-    "        try:\n",
-    "            if 'text' in mime_type or 'document' in mime_type:\n",
-    "                # For Google Docs, export as plain text\n",
-    "                if 'document' in mime_type:\n",
-    "                    request = self.drive_service.files().export_media(\n",
-    "                        fileId=file_id, mimeType='text/plain'\n",
-    "                    )\n",
-    "                else:\n",
-    "                    request = self.drive_service.files().get_media(fileId=file_id)\n",
-    "                \n",
-    "                file_content = io.BytesIO()\n",
-    "                downloader = MediaIoBaseDownload(file_content, request)\n",
-    "                done = False\n",
-    "                while done is False:\n",
-    "                    status, done = downloader.next_chunk()\n",
-    "                \n",
-    "                return file_content.getvalue().decode('utf-8')\n",
-    "            \n",
-    "            elif 'spreadsheet' in mime_type:\n",
-    "                # For Google Sheets, export as CSV\n",
-    "                request = self.drive_service.files().export_media(\n",
-    "                    fileId=file_id, mimeType='text/csv'\n",
-    "                )\n",
-    "                file_content = io.BytesIO()\n",
-    "                downloader = MediaIoBaseDownload(file_content, request)\n",
-    "                done = False\n",
-    "                while done is False:\n",
-    "                    status, done = downloader.next_chunk()\n",
-    "                \n",
-    "                return file_content.getvalue().decode('utf-8')\n",
-    "            \n",
-    "            else:\n",
-    "                return \"File type not supported for text extraction\"\n",
-    "                \n",
-    "        except Exception as e:\n",
-    "            return f\"Error reading file: {str(e)}\"\n",
-    "    \n",
-    "    def query_gpt_with_context(self, user_query, file_contents):\n",
-    "        \"\"\"Send query to GPT with file context\"\"\"\n",
-    "        context = \"\\n\\n\".join([\n",
-    "            f\"File: {content['name']}\\nContent: {content['text'][:2000]}...\"\n",
-    "            for content in file_contents\n",
-    "        ])\n",
-    "        \n",
-    "        messages = [\n",
-    "            {\n",
-    "                \"role\": \"system\", \n",
-    "                \"content\": \"\"\"\n",
-    "                You are an AI assistant that can analyze documents from Google Drive. \n",
-    "                Use the provided file contents to answer user questions.\"\"\"\n",
-    "            },\n",
-    "            {\n",
-    "                \"role\": \"user\", \n",
-    "                \"content\": f\"Context from Google Drive files:\\n{context}\\n\\nUser Question: {user_query}\"\n",
-    "            }\n",
-    "        ]\n",
-    "        \n",
-    "        response = openai.chat.completions.create(\n",
-    "            model=\"gpt-4o-mini\",\n",
-    "            messages=messages,\n",
-    "            max_tokens=1000\n",
-    "        )\n",
-    "        \n",
-    "        return response.choices[0].message.content\n",
-    "    \n",
-    "    def process_query(self, user_query, search_terms=None):\n",
-    "        \"\"\"Main function to process user queries\"\"\"\n",
-    "        # Extract search terms from query if not provided\n",
-    "        if not search_terms:\n",
-    "            search_terms = user_query.split()[:3]  # Simple extraction\n",
-    "        \n",
-    "        # Search for relevant files\n",
-    "        files = []\n",
-    "        for term in search_terms:\n",
-    "            files.extend(self.search_files(term))\n",
-    "        \n",
-    "        # Remove duplicates\n",
-    "        unique_files = {f['id']: f for f in files}.values()\n",
-    "        \n",
-    "        # Get content from top 3 most relevant files\n",
-    "        file_contents = []\n",
-    "        for file in list(unique_files)[:3]:\n",
-    "            content = self.get_file_content(file['id'], file['mimeType'])\n",
-    "            file_contents.append({\n",
-    "                'name': file['name'],\n",
-    "                'text': content\n",
-    "            })\n",
-    "        \n",
-    "        # Query GPT with context\n",
-    "        if file_contents:\n",
-    "            response = self.query_gpt_with_context(user_query, file_contents)\n",
-    "            return {\n",
-    "                'answer': response,\n",
-    "                'sources': [f['name'] for f in file_contents]\n",
-    "            }\n",
-    "        else:\n",
-    "            return {\n",
-    "                'answer': \"No relevant files found in your Google Drive.\",\n",
-    "                'sources': []\n",
-    "            }"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "3c2c1ccf-9ade-482d-a170-978e97bc1c08",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Answer: Blue Berry specializes in smart agriculture and precision farming, focusing on creating AI-powered drones and IoT devices. These technologies help farmers monitor crop health, manage irrigation, and improve yield by utilizing real-time data.\n",
-      "Sources: ['About the Company']\n"
-     ]
-    }
-   ],
-   "source": [
-    "if __name__ == \"__main__\":\n",
-    "    integration = GPTDriveIntegration()\n",
-    "    \n",
-    "    # Test query\n",
-    "    result = integration.process_query(\n",
-    "        \"What is the company about?\"\n",
-    "    )\n",
-    "    \n",
-    "    print(\"Answer:\", result['answer'])\n",
-    "    print(\"Sources:\", result['sources'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "120e7c93-b38a-4c89-8e76-5b0170d22548",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "634b9787-d493-46e5-8114-0851c6172ed6",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🔍 Starting Google Drive API Diagnostic...\n",
-      "==================================================\n",
-      "\n",
-      "1️⃣ Checking service account file...\n",
-      "✅ Service account file is valid\n",
-      "   📧 Service account email: rag-base@rag-system-463320.iam.gserviceaccount.com\n",
-      "   🏗️ Project ID: rag-system-463320\n",
-      "\n",
-      "2️⃣ Checking credentials...\n",
-      "✅ Credentials created successfully\n",
-      "\n",
-      "3️⃣ Testing API connection...\n",
-      "✅ Successfully connected to Google Drive API\n",
-      "   👤 Connected as: rag-base@rag-system-463320.iam.gserviceaccount.com\n",
-      "\n",
-      "4️⃣ Checking basic permissions...\n",
-      "✅ Can access Drive API - found 0 files in test query\n",
-      "⚠️ No files found - this might mean:\n",
-      "   • Service account has no shared files\n",
-      "   • No files are shared with the service account\n",
-      "\n",
-      "5️⃣ Testing access to 'Blue berry' folder...\n",
-      "❌ Folder 'Blue berry' not found or not accessible\n",
-      "💡 Possible solutions:\n",
-      "   • Make sure the folder exists in Google Drive\n",
-      "   • Share the folder with your service account email\n",
-      "   • Check folder name spelling (case sensitive)\n",
-      "\n",
-      "✅ All basic checks passed!\n"
-     ]
-    }
-   ],
-   "source": [
-    "import json\n",
-    "from google.auth.exceptions import RefreshError\n",
-    "from googleapiclient.errors import HttpError\n",
-    "\n",
-    "class GPTDriveTroubleshooter:\n",
-    "    def __init__(self, service_account_file_path):\n",
-    "        self.service_account_file = service_account_file_path\n",
-    "        self.credentials = None\n",
-    "        self.drive_service = None\n",
-    "        \n",
-    "    def run_full_diagnostic(self):\n",
-    "        \"\"\"Run complete diagnostic check\"\"\"\n",
-    "        print(\"🔍 Starting Google Drive API Diagnostic...\")\n",
-    "        print(\"=\" * 50)\n",
-    "        \n",
-    "        # Step 1: Check service account file\n",
-    "        if not self.check_service_account_file():\n",
-    "            return False\n",
-    "            \n",
-    "        # Step 2: Check credentials\n",
-    "        if not self.check_credentials():\n",
-    "            return False\n",
-    "            \n",
-    "        # Step 3: Test API connection\n",
-    "        if not self.test_api_connection():\n",
-    "            return False\n",
-    "            \n",
-    "        # Step 4: Check permissions\n",
-    "        if not self.check_basic_permissions():\n",
-    "            return False\n",
-    "            \n",
-    "        # Step 5: Test folder access\n",
-    "        self.test_folder_access()\n",
-    "        \n",
-    "        print(\"\\n✅ All basic checks passed!\")\n",
-    "        return True\n",
-    "    \n",
-    "    def check_service_account_file(self):\n",
-    "        \"\"\"Check if service account file exists and is valid\"\"\"\n",
-    "        print(\"\\n1️⃣ Checking service account file...\")\n",
-    "        \n",
-    "        if not os.path.exists(self.service_account_file):\n",
-    "            print(f\"❌ Service account file not found: {self.service_account_file}\")\n",
-    "            print(\"💡 Make sure you've downloaded the JSON key file from Google Cloud Console\")\n",
-    "            return False\n",
-    "        \n",
-    "        try:\n",
-    "            with open(self.service_account_file, 'r') as f:\n",
-    "                service_account_info = json.load(f)\n",
-    "            \n",
-    "            required_fields = ['type', 'project_id', 'private_key_id', 'private_key', 'client_email']\n",
-    "            missing_fields = [field for field in required_fields if field not in service_account_info]\n",
-    "            \n",
-    "            if missing_fields:\n",
-    "                print(f\"❌ Service account file missing required fields: {missing_fields}\")\n",
-    "                return False\n",
-    "            \n",
-    "            print(f\"✅ Service account file is valid\")\n",
-    "            print(f\"   📧 Service account email: {service_account_info['client_email']}\")\n",
-    "            print(f\"   🏗️ Project ID: {service_account_info['project_id']}\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except json.JSONDecodeError:\n",
-    "            print(\"❌ Service account file is not valid JSON\")\n",
-    "            return False\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error reading service account file: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def check_credentials(self):\n",
-    "        \"\"\"Check if credentials can be created\"\"\"\n",
-    "        print(\"\\n2️⃣ Checking credentials...\")\n",
-    "        \n",
-    "        try:\n",
-    "            self.credentials = service_account.Credentials.from_service_account_file(\n",
-    "                self.service_account_file,\n",
-    "                scopes=['https://www.googleapis.com/auth/drive.readonly']\n",
-    "            )\n",
-    "            print(\"✅ Credentials created successfully\")\n",
-    "            return True\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Failed to create credentials: {e}\")\n",
-    "            print(\"💡 Check if your service account key file is corrupted\")\n",
-    "            return False\n",
-    "    \n",
-    "    def test_api_connection(self):\n",
-    "        \"\"\"Test basic API connection\"\"\"\n",
-    "        print(\"\\n3️⃣ Testing API connection...\")\n",
-    "        \n",
-    "        try:\n",
-    "            self.drive_service = build('drive', 'v3', credentials=self.credentials)\n",
-    "            \n",
-    "            # Try a simple API call\n",
-    "            about = self.drive_service.about().get(fields=\"user, storageQuota\").execute()\n",
-    "            print(\"✅ Successfully connected to Google Drive API\")\n",
-    "            print(f\"   👤 Connected as: {about.get('user', {}).get('emailAddress', 'Unknown')}\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except HttpError as e:\n",
-    "            print(f\"❌ HTTP Error connecting to API: {e}\")\n",
-    "            if e.resp.status == 403:\n",
-    "                print(\"💡 This is likely a permissions issue - check if Drive API is enabled\")\n",
-    "            return False\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Failed to connect to API: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def check_basic_permissions(self):\n",
-    "        \"\"\"Check basic file listing permissions\"\"\"\n",
-    "        print(\"\\n4️⃣ Checking basic permissions...\")\n",
-    "        \n",
-    "        try:\n",
-    "            # Try to list files (this should work with readonly access)\n",
-    "            results = self.drive_service.files().list(\n",
-    "                pageSize=1,\n",
-    "                fields=\"files(id, name)\"\n",
-    "            ).execute()\n",
-    "            \n",
-    "            files = results.get('files', [])\n",
-    "            print(f\"✅ Can access Drive API - found {len(files)} files in test query\")\n",
-    "            \n",
-    "            if len(files) == 0:\n",
-    "                print(\"⚠️ No files found - this might mean:\")\n",
-    "                print(\"   • Service account has no shared files\")\n",
-    "                print(\"   • No files are shared with the service account\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except HttpError as e:\n",
-    "            print(f\"❌ Permission error: {e}\")\n",
-    "            if e.resp.status == 403:\n",
-    "                print(\"💡 Common causes:\")\n",
-    "                print(\"   • Google Drive API not enabled in Google Cloud Console\")\n",
-    "                print(\"   • Service account doesn't have proper permissions\")\n",
-    "            return False\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error checking permissions: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def test_folder_access(self, folder_name=\"Blue berry\"):\n",
-    "        \"\"\"Test access to specific folder\"\"\"\n",
-    "        print(f\"\\n5️⃣ Testing access to '{folder_name}' folder...\")\n",
-    "        \n",
-    "        try:\n",
-    "            # Search for the folder\n",
-    "            query = f\"name='{folder_name}' and mimeType='application/vnd.google-apps.folder' and trashed=false\"\n",
-    "            results = self.drive_service.files().list(\n",
-    "                q=query,\n",
-    "                fields=\"files(id, name, owners, permissions)\"\n",
-    "            ).execute()\n",
-    "            \n",
-    "            folders = results.get('files', [])\n",
-    "            \n",
-    "            if not folders:\n",
-    "                print(f\"❌ Folder '{folder_name}' not found or not accessible\")\n",
-    "                print(\"💡 Possible solutions:\")\n",
-    "                print(\"   • Make sure the folder exists in Google Drive\")\n",
-    "                print(\"   • Share the folder with your service account email\")\n",
-    "                print(\"   • Check folder name spelling (case sensitive)\")\n",
-    "                return False\n",
-    "            \n",
-    "            folder = folders[0]\n",
-    "            print(f\"✅ Found folder '{folder_name}'\")\n",
-    "            print(f\"   📁 Folder ID: {folder['id']}\")\n",
-    "            \n",
-    "            # Test listing files in the folder\n",
-    "            files_in_folder = self.drive_service.files().list(\n",
-    "                q=f\"'{folder['id']}' in parents and trashed=false\",\n",
-    "                fields=\"files(id, name, mimeType)\"\n",
-    "            ).execute()\n",
-    "            \n",
-    "            files = files_in_folder.get('files', [])\n",
-    "            print(f\"   📄 Contains {len(files)} files\")\n",
-    "            \n",
-    "            if files:\n",
-    "                print(\"   📝 Sample files:\")\n",
-    "                for file in files[:3]:  # Show first 3 files\n",
-    "                    print(f\"      • {file['name']} ({file['mimeType']})\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except HttpError as e:\n",
-    "            print(f\"❌ HTTP Error accessing folder: {e}\")\n",
-    "            return False\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error accessing folder: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def check_file_permissions(self, file_id):\n",
-    "        \"\"\"Check permissions for a specific file\"\"\"\n",
-    "        print(f\"\\n🔍 Checking permissions for file ID: {file_id}\")\n",
-    "        \n",
-    "        try:\n",
-    "            file_info = self.drive_service.files().get(\n",
-    "                fileId=file_id,\n",
-    "                fields=\"id, name, mimeType, owners, permissions, capabilities\"\n",
-    "            ).execute()\n",
-    "            \n",
-    "            print(f\"✅ File: {file_info['name']}\")\n",
-    "            print(f\"   🔗 Type: {file_info['mimeType']}\")\n",
-    "            print(f\"   👤 Owner: {file_info.get('owners', [{}])[0].get('emailAddress', 'Unknown')}\")\n",
-    "            \n",
-    "            capabilities = file_info.get('capabilities', {})\n",
-    "            print(f\"   📖 Can read: {capabilities.get('canDownload', False)}\")\n",
-    "            print(f\"   📤 Can export: {capabilities.get('canExport', False)}\")\n",
-    "            \n",
-    "        except HttpError as e:\n",
-    "            print(f\"❌ Cannot access file: {e}\")\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error: {e}\")\n",
-    "    \n",
-    "    def get_sharing_instructions(self):\n",
-    "        \"\"\"Provide step-by-step sharing instructions\"\"\"\n",
-    "        print(\"\\n📋 HOW TO SHARE FOLDER WITH SERVICE ACCOUNT:\")\n",
-    "        print(\"=\" * 50)\n",
-    "        \n",
-    "        if self.credentials:\n",
-    "            service_email = self.credentials.service_account_email\n",
-    "            print(f\"1. Copy this service account email: {service_email}\")\n",
-    "        else:\n",
-    "            print(\"1. Find your service account email in the JSON key file (client_email field)\")\n",
-    "        \n",
-    "        print(\"2. Open Google Drive in your browser\")\n",
-    "        print(\"3. Right-click on your 'Blue berry' folder\")\n",
-    "        print(\"4. Select 'Share'\")\n",
-    "        print(\"5. Paste the service account email\")\n",
-    "        print(\"6. Set permission to 'Viewer' or 'Editor'\")\n",
-    "        print(\"7. Click 'Send' (you can uncheck 'Notify people')\")\n",
-    "        print(\"8. Wait a few minutes for permissions to propagate\")\n",
-    "        \n",
-    "    def run_connection_test(self):\n",
-    "        \"\"\"Quick connection test\"\"\"\n",
-    "        print(\"🚀 Quick Connection Test\")\n",
-    "        print(\"-\" * 30)\n",
-    "        \n",
-    "        try:\n",
-    "            self.credentials = service_account.Credentials.from_service_account_file(\n",
-    "                self.service_account_file,\n",
-    "                scopes=['https://www.googleapis.com/auth/drive.readonly']\n",
-    "            )\n",
-    "            \n",
-    "            service = build('drive', 'v3', credentials=self.credentials)\n",
-    "            \n",
-    "            # Test basic query\n",
-    "            results = service.files().list(pageSize=5).execute()\n",
-    "            files = results.get('files', [])\n",
-    "            \n",
-    "            print(f\"✅ Connected! Found {len(files)} accessible files\")\n",
-    "            print(f\"📧 Service account: {self.credentials.service_account_email}\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Connection failed: {e}\")\n",
-    "            return False\n",
-    "\n",
-    "# Usage Examples\n",
-    "def troubleshoot_drive_access():\n",
-    "    \"\"\"Main troubleshooting function\"\"\"\n",
-    "    service_account_file = os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE')\n",
-    "    \n",
-    "    if not service_account_file:\n",
-    "        print(\"❌ GOOGLE_SERVICE_ACCOUNT_FILE environment variable not set\")\n",
-    "        print(\"💡 Add this to your .env file:\")\n",
-    "        print(\"GOOGLE_SERVICE_ACCOUNT_FILE=path/to/your/service-account-key.json\")\n",
-    "        return\n",
-    "    \n",
-    "    troubleshooter = GPTDriveTroubleshooter(service_account_file)\n",
-    "    \n",
-    "    # Run full diagnostic\n",
-    "    success = troubleshooter.run_full_diagnostic()\n",
-    "    \n",
-    "    if not success:\n",
-    "        print(\"\\n\" + \"=\"*50)\n",
-    "        troubleshooter.get_sharing_instructions()\n",
-    "    \n",
-    "    return success\n",
-    "\n",
-    "# Quick test function\n",
-    "def quick_test():\n",
-    "    \"\"\"Quick test to verify everything works\"\"\"\n",
-    "    service_account_file = os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE')\n",
-    "    troubleshooter = GPTDriveTroubleshooter(service_account_file)\n",
-    "    return troubleshooter.run_connection_test()\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    # Uncomment the test you want to run:\n",
-    "    \n",
-    "    # Full diagnostic (recommended for first-time setup)\n",
-    "    troubleshoot_drive_access()\n",
-    "    \n",
-    "    # Quick test (for regular checks)\n",
-    "    # quick_test()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6b336789-d402-455d-a631-26e987d79ed6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "troubleshooter = GPTDriveTroubleshooter(GOOGLE_SERVICE_ACCOUNT_FILE)\n",
-    "troubleshooter.test_folder_access(\"Blue berry\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e2786c67-215e-46b0-b3ca-2c3176bd8971",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Add this test function to verify access\n",
-    "def test_folder_access():\n",
-    "    integration = GPTDriveIntegration()\n",
-    "    folder_id = integration.find_folder_by_name(\"Blue berry\")\n",
-    "    if folder_id:\n",
-    "        print(\"✅ Successfully found 'Blue berry' folder!\")\n",
-    "        \n",
-    "        # List files in the folder\n",
-    "        results = integration.drive_service.files().list(\n",
-    "            q=f\"'{folder_id}' in parents and trashed=false\",\n",
-    "            fields=\"files(id, name, mimeType)\"\n",
-    "        ).execute()\n",
-    "        \n",
-    "        files = results.get('files', [])\n",
-    "        print(f\"Found {len(files)} files in the folder:\")\n",
-    "        for file in files[:5]:  # Show first 5 files\n",
-    "            print(f\"  - {file['name']} ({file['mimeType']})\")\n",
-    "    else:\n",
-    "        print(\"❌ Could not access 'Blue berry' folder\")\n",
-    "        print(\"Make sure you've shared the folder with your service account\")\n",
-    "\n",
-    "# Run this test first\n",
-    "test_folder_access()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c3dede9f-5e01-436d-a7b7-905e1646baf9",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b933c8b6-add6-40fc-827f-e5e07447ac00",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#Troubleshooting"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "b63a1f4b-1315-44fe-ba84-93fb1c2655cc",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🔍 Searching for 'Blue Berry' folder...\n",
-      "Total folders found: 0\n",
-      "No folders found or error occurred.\n"
-     ]
-    }
-   ],
-   "source": [
-    "import os\n",
-    "from google.oauth2 import service_account\n",
-    "from googleapiclient.discovery import build\n",
-    "\n",
-    "class DrivefolderLister:\n",
-    "    def __init__(self):\n",
-    "        # Initialize Google Drive API\n",
-    "        self.credentials = service_account.Credentials.from_service_account_file(\n",
-    "            os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE'),\n",
-    "            scopes=['https://www.googleapis.com/auth/drive.readonly']\n",
-    "        )\n",
-    "        self.drive_service = build('drive', 'v3', credentials=self.credentials)\n",
-    "    \n",
-    "    def get_all_folders(self):\n",
-    "        \"\"\"Get ALL folders in the Google Drive\"\"\"\n",
-    "        try:\n",
-    "            # Query to get all folders (not trashed)\n",
-    "            query = \"mimeType='application/vnd.google-apps.folder' and trashed=false\"\n",
-    "            \n",
-    "            all_folders = []\n",
-    "            page_token = None\n",
-    "            \n",
-    "            while True:\n",
-    "                results = self.drive_service.files().list(\n",
-    "                    q=query,\n",
-    "                    fields=\"nextPageToken, files(id, name, parents)\",\n",
-    "                    pageSize=1000,  # Maximum allowed\n",
-    "                    pageToken=page_token\n",
-    "                ).execute()\n",
-    "                \n",
-    "                folders = results.get('files', [])\n",
-    "                all_folders.extend(folders)\n",
-    "                \n",
-    "                page_token = results.get('nextPageToken')\n",
-    "                if not page_token:\n",
-    "                    break\n",
-    "            \n",
-    "            print(f\"Total folders found: {len(all_folders)}\")\n",
-    "            return all_folders\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"Error retrieving folders: {e}\")\n",
-    "            return []\n",
-    "    \n",
-    "    def build_folder_tree(self, folders):\n",
-    "        \"\"\"Build a tree structure from the flat list of folders\"\"\"\n",
-    "        # Create a dictionary for quick lookup\n",
-    "        folder_dict = {folder['id']: folder for folder in folders}\n",
-    "        \n",
-    "        # Add root folder\n",
-    "        folder_dict['root'] = {'id': 'root', 'name': 'My Drive', 'parents': []}\n",
-    "        \n",
-    "        # Build the tree structure\n",
-    "        tree = {}\n",
-    "        \n",
-    "        def build_path(folder_id, visited=None):\n",
-    "            if visited is None:\n",
-    "                visited = set()\n",
-    "            \n",
-    "            if folder_id in visited:  # Prevent infinite loops\n",
-    "                return \"CIRCULAR_REFERENCE\"\n",
-    "            \n",
-    "            visited.add(folder_id)\n",
-    "            \n",
-    "            if folder_id not in folder_dict:\n",
-    "                return \"UNKNOWN\"\n",
-    "            \n",
-    "            folder = folder_dict[folder_id]\n",
-    "            \n",
-    "            if folder_id == 'root':\n",
-    "                return \"My Drive\"\n",
-    "            \n",
-    "            parents = folder.get('parents', [])\n",
-    "            if not parents:\n",
-    "                return folder['name']\n",
-    "            \n",
-    "            parent_path = build_path(parents[0], visited.copy())\n",
-    "            return f\"{parent_path}/{folder['name']}\"\n",
-    "        \n",
-    "        # Build paths for all folders\n",
-    "        folder_paths = []\n",
-    "        for folder in folders:\n",
-    "            path = build_path(folder['id'])\n",
-    "            folder_paths.append({\n",
-    "                'name': folder['name'],\n",
-    "                'id': folder['id'],\n",
-    "                'path': path\n",
-    "            })\n",
-    "        \n",
-    "        return folder_paths\n",
-    "    \n",
-    "    def search_folder_by_name(self, folder_name, folders_with_paths):\n",
-    "        \"\"\"Search for folders by name (case-insensitive)\"\"\"\n",
-    "        matches = []\n",
-    "        search_name = folder_name.lower()\n",
-    "        \n",
-    "        for folder in folders_with_paths:\n",
-    "            if search_name in folder['name'].lower():\n",
-    "                matches.append(folder)\n",
-    "        \n",
-    "        return matches\n",
-    "    \n",
-    "    def display_all_folders(self, folders_with_paths, search_term=None):\n",
-    "        \"\"\"Display all folders in a readable format\"\"\"\n",
-    "        if search_term:\n",
-    "            print(f\"\\n=== Searching for folders containing '{search_term}' ===\")\n",
-    "            matches = self.search_folder_by_name(search_term, folders_with_paths)\n",
-    "            if matches:\n",
-    "                print(f\"Found {len(matches)} matching folders:\")\n",
-    "                for folder in matches:\n",
-    "                    print(f\"📁 {folder['name']}\")\n",
-    "                    print(f\"   Path: {folder['path']}\")\n",
-    "                    print(f\"   ID: {folder['id']}\")\n",
-    "                    print()\n",
-    "            else:\n",
-    "                print(f\"No folders found containing '{search_term}'\")\n",
-    "        else:\n",
-    "            print(f\"\\n=== All {len(folders_with_paths)} folders in your Google Drive ===\")\n",
-    "            \n",
-    "            # Sort by path for better readability\n",
-    "            sorted_folders = sorted(folders_with_paths, key=lambda x: x['path'])\n",
-    "            \n",
-    "            for folder in sorted_folders:\n",
-    "                print(f\"📁 {folder['path']}\")\n",
-    "                # print(f\"   ID: {folder['id']}\")  # Uncomment if you need IDs\n",
-    "    \n",
-    "    def find_blue_berry_folder(self):\n",
-    "        \"\"\"Specifically look for the Blue Berry folder\"\"\"\n",
-    "        print(\"🔍 Searching for 'Blue Berry' folder...\")\n",
-    "        \n",
-    "        folders = self.get_all_folders()\n",
-    "        if not folders:\n",
-    "            print(\"No folders found or error occurred.\")\n",
-    "            return\n",
-    "        \n",
-    "        folders_with_paths = self.build_folder_tree(folders)\n",
-    "        \n",
-    "        # Search for Blue Berry specifically\n",
-    "        blue_berry_matches = self.search_folder_by_name(\"blue berry\", folders_with_paths)\n",
-    "        \n",
-    "        if blue_berry_matches:\n",
-    "            print(f\"\\n✅ Found {len(blue_berry_matches)} 'Blue Berry' folder(s):\")\n",
-    "            for folder in blue_berry_matches:\n",
-    "                print(f\"📁 {folder['name']}\")\n",
-    "                print(f\"   Full Path: {folder['path']}\")\n",
-    "                print(f\"   Folder ID: {folder['id']}\")\n",
-    "                print()\n",
-    "        else:\n",
-    "            print(\"\\n❌ No 'Blue Berry' folder found.\")\n",
-    "            print(\"Let me show you all folders to help you locate it:\")\n",
-    "            \n",
-    "            # Show all folders if Blue Berry not found\n",
-    "            self.display_all_folders(folders_with_paths)\n",
-    "    \n",
-    "    def interactive_folder_search(self):\n",
-    "        \"\"\"Interactive search for any folder\"\"\"\n",
-    "        print(\"📂 Google Drive Folder Explorer\")\n",
-    "        print(\"=\" * 40)\n",
-    "        \n",
-    "        folders = self.get_all_folders()\n",
-    "        if not folders:\n",
-    "            print(\"No folders found or error occurred.\")\n",
-    "            return\n",
-    "        \n",
-    "        folders_with_paths = self.build_folder_tree(folders)\n",
-    "        \n",
-    "        while True:\n",
-    "            print(\"\\nOptions:\")\n",
-    "            print(\"1. Search for a specific folder\")\n",
-    "            print(\"2. Show all folders\")\n",
-    "            print(\"3. Find 'Blue Berry' folder\")\n",
-    "            print(\"4. Exit\")\n",
-    "            \n",
-    "            choice = input(\"\\nEnter your choice (1-4): \").strip()\n",
-    "            \n",
-    "            if choice == '1':\n",
-    "                search_term = input(\"Enter folder name to search: \").strip()\n",
-    "                if search_term:\n",
-    "                    self.display_all_folders(folders_with_paths, search_term)\n",
-    "            \n",
-    "            elif choice == '2':\n",
-    "                self.display_all_folders(folders_with_paths)\n",
-    "            \n",
-    "            elif choice == '3':\n",
-    "                blue_berry_matches = self.search_folder_by_name(\"blue berry\", folders_with_paths)\n",
-    "                if blue_berry_matches:\n",
-    "                    print(f\"\\n✅ Found 'Blue Berry' folder(s):\")\n",
-    "                    for folder in blue_berry_matches:\n",
-    "                        print(f\"📁 {folder['name']} -> {folder['path']}\")\n",
-    "                else:\n",
-    "                    print(\"\\n❌ 'Blue Berry' folder not found in your Drive.\")\n",
-    "            \n",
-    "            elif choice == '4':\n",
-    "                print(\"Goodbye!\")\n",
-    "                break\n",
-    "            \n",
-    "            else:\n",
-    "                print(\"Invalid choice. Please try again.\")\n",
-    "\n",
-    "def main():\n",
-    "    \"\"\"Main function to run the folder lister\"\"\"\n",
-    "    try:\n",
-    "        lister = DrivefolderLister()\n",
-    "        \n",
-    "        # Quick search for Blue Berry folder\n",
-    "        lister.find_blue_berry_folder()\n",
-    "        \n",
-    "        # Uncomment the line below for interactive mode\n",
-    "        # lister.interactive_folder_search()\n",
-    "        \n",
-    "    except Exception as e:\n",
-    "        print(f\"Error initializing Drive connection: {e}\")\n",
-    "        print(\"Make sure your GOOGLE_SERVICE_ACCOUNT_FILE environment variable is set correctly.\")\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    main()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "29a61039-9043-44d5-94b1-4847350b2200",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "7350d687-f76e-46f4-a30b-0518e5b8236e",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🚀 Google Drive API Diagnostic Tool\n",
-      "==================================================\n",
-      "🔧 Testing Environment Variables...\n",
-      "----------------------------------------\n",
-      "✅ GOOGLE_SERVICE_ACCOUNT_FILE: C:/Users/Uche Buzz/myprojects/RAG/rag-system-463320-f292991d0516.json\n",
-      "✅ Service account file exists\n",
-      "✅ Service account file is valid JSON\n",
-      "✅ All required fields present in service account file\n",
-      "📧 Service account email: rag-base@rag-system-463320.iam.gserviceaccount.com\n",
-      "✅ OPENAI_API_KEY: ************************************************************************************************************************************************************K1OkRRkA\n",
-      "\n",
-      "🔑 Testing Credentials Loading...\n",
-      "----------------------------------------\n",
-      "\n",
-      "Testing scope set 1: ['https://www.googleapis.com/auth/drive.readonly']\n",
-      "✅ Credentials loaded successfully with scopes: ['https://www.googleapis.com/auth/drive.readonly']\n",
-      "\n",
-      "🔧 Testing Drive Service Creation...\n",
-      "----------------------------------------\n",
-      "✅ Google Drive service created successfully\n",
-      "\n",
-      "📡 Testing Basic API Call...\n",
-      "----------------------------------------\n",
-      "✅ API call successful!\n",
-      "📧 Connected as: rag-base@rag-system-463320.iam.gserviceaccount.com\n",
-      "👤 Display name: rag-base@rag-system-463320.iam.gserviceaccount.com\n",
-      "\n",
-      "🏠 Testing Root Folder Access...\n",
-      "----------------------------------------\n",
-      "✅ Root folder accessible\n",
-      "📁 Root folder name: My Drive\n",
-      "📄 Items in root folder: 0\n",
-      "\n",
-      "📁 Testing File Listing...\n",
-      "----------------------------------------\n",
-      "Test 1: Listing all files (including documents)...\n",
-      "✅ Found 3 files total\n",
-      "📄 First few files:\n",
-      "   - Blue Berry (application/vnd.google-apps.folder)\n",
-      "   - Blue Berry Safety Protocols and Training Guidelines (application/vnd.google-apps.document)\n",
-      "   - About the Company (application/vnd.google-apps.document)\n",
-      "\n",
-      "Test 2: Listing folders only...\n",
-      "✅ Found 1 folders\n",
-      "📁 Folders found:\n",
-      "   - Blue Berry (ID: 1AYaS0yt_srFlgdE4mSNlqA6FLm10rdt4)\n",
-      "\n",
-      "✅ All diagnostic tests passed!\n",
-      "🎉 Your Google Drive API connection is working correctly!\n"
-     ]
-    }
-   ],
-   "source": [
-    "import os\n",
-    "from google.oauth2 import service_account\n",
-    "from googleapiclient.discovery import build\n",
-    "from googleapiclient.errors import HttpError\n",
-    "import json\n",
-    "\n",
-    "class DriveConnectionDiagnostic:\n",
-    "    def __init__(self):\n",
-    "        self.credentials = None\n",
-    "        self.drive_service = None\n",
-    "        self.setup_success = False\n",
-    "    \n",
-    "    def test_environment_variables(self):\n",
-    "        \"\"\"Test if environment variables are set correctly\"\"\"\n",
-    "        print(\"🔧 Testing Environment Variables...\")\n",
-    "        print(\"-\" * 40)\n",
-    "        \n",
-    "        service_account_file = os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE')\n",
-    "        openai_key = os.getenv('OPENAI_API_KEY')\n",
-    "        \n",
-    "        if service_account_file:\n",
-    "            print(f\"✅ GOOGLE_SERVICE_ACCOUNT_FILE: {service_account_file}\")\n",
-    "            \n",
-    "            # Check if file exists\n",
-    "            if os.path.exists(service_account_file):\n",
-    "                print(f\"✅ Service account file exists\")\n",
-    "                \n",
-    "                # Check if file is readable\n",
-    "                try:\n",
-    "                    with open(service_account_file, 'r') as f:\n",
-    "                        service_data = json.load(f)\n",
-    "                    print(f\"✅ Service account file is valid JSON\")\n",
-    "                    \n",
-    "                    # Check required fields\n",
-    "                    required_fields = ['type', 'project_id', 'private_key_id', 'private_key', 'client_email']\n",
-    "                    missing_fields = [field for field in required_fields if field not in service_data]\n",
-    "                    \n",
-    "                    if missing_fields:\n",
-    "                        print(f\"❌ Missing required fields in service account file: {missing_fields}\")\n",
-    "                        return False\n",
-    "                    else:\n",
-    "                        print(f\"✅ All required fields present in service account file\")\n",
-    "                        print(f\"📧 Service account email: {service_data.get('client_email')}\")\n",
-    "                        \n",
-    "                except json.JSONDecodeError:\n",
-    "                    print(f\"❌ Service account file is not valid JSON\")\n",
-    "                    return False\n",
-    "                except Exception as e:\n",
-    "                    print(f\"❌ Error reading service account file: {e}\")\n",
-    "                    return False\n",
-    "                    \n",
-    "            else:\n",
-    "                print(f\"❌ Service account file does not exist at: {service_account_file}\")\n",
-    "                return False\n",
-    "        else:\n",
-    "            print(f\"❌ GOOGLE_SERVICE_ACCOUNT_FILE environment variable not set\")\n",
-    "            return False\n",
-    "        \n",
-    "        if openai_key:\n",
-    "            print(f\"✅ OPENAI_API_KEY: {'*' * (len(openai_key) - 8) + openai_key[-8:]}\")\n",
-    "        else:\n",
-    "            print(f\"⚠️ OPENAI_API_KEY not set (not required for folder listing)\")\n",
-    "        \n",
-    "        return True\n",
-    "    \n",
-    "    def test_credentials_loading(self):\n",
-    "        \"\"\"Test if credentials can be loaded\"\"\"\n",
-    "        print(\"\\n🔑 Testing Credentials Loading...\")\n",
-    "        print(\"-\" * 40)\n",
-    "        \n",
-    "        try:\n",
-    "            service_account_file = os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE')\n",
-    "            \n",
-    "            # Try different scope combinations\n",
-    "            scopes_to_test = [\n",
-    "                ['https://www.googleapis.com/auth/drive.readonly'],\n",
-    "                ['https://www.googleapis.com/auth/drive'],\n",
-    "                ['https://www.googleapis.com/auth/drive.metadata.readonly'],\n",
-    "                ['https://www.googleapis.com/auth/drive.file']\n",
-    "            ]\n",
-    "            \n",
-    "            for i, scopes in enumerate(scopes_to_test):\n",
-    "                try:\n",
-    "                    print(f\"\\nTesting scope set {i+1}: {scopes}\")\n",
-    "                    self.credentials = service_account.Credentials.from_service_account_file(\n",
-    "                        service_account_file,\n",
-    "                        scopes=scopes\n",
-    "                    )\n",
-    "                    print(f\"✅ Credentials loaded successfully with scopes: {scopes}\")\n",
-    "                    return True\n",
-    "                except Exception as e:\n",
-    "                    print(f\"❌ Failed to load credentials with scopes {scopes}: {e}\")\n",
-    "            \n",
-    "            return False\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error loading credentials: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def test_drive_service_creation(self):\n",
-    "        \"\"\"Test if Drive service can be created\"\"\"\n",
-    "        print(\"\\n🔧 Testing Drive Service Creation...\")\n",
-    "        print(\"-\" * 40)\n",
-    "        \n",
-    "        try:\n",
-    "            if not self.credentials:\n",
-    "                print(\"❌ No credentials available\")\n",
-    "                return False\n",
-    "            \n",
-    "            self.drive_service = build('drive', 'v3', credentials=self.credentials)\n",
-    "            print(\"✅ Google Drive service created successfully\")\n",
-    "            return True\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error creating Drive service: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def test_basic_api_call(self):\n",
-    "        \"\"\"Test basic API functionality\"\"\"\n",
-    "        print(\"\\n📡 Testing Basic API Call...\")\n",
-    "        print(\"-\" * 40)\n",
-    "        \n",
-    "        try:\n",
-    "            if not self.drive_service:\n",
-    "                print(\"❌ No Drive service available\")\n",
-    "                return False\n",
-    "            \n",
-    "            # Test getting user info\n",
-    "            about = self.drive_service.about().get(fields=\"user\").execute()\n",
-    "            user_info = about.get('user', {})\n",
-    "            print(f\"✅ API call successful!\")\n",
-    "            print(f\"📧 Connected as: {user_info.get('emailAddress', 'Unknown')}\")\n",
-    "            print(f\"👤 Display name: {user_info.get('displayName', 'Unknown')}\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except HttpError as e:\n",
-    "            print(f\"❌ HTTP Error: {e}\")\n",
-    "            if e.resp.status == 403:\n",
-    "                print(\"   This might be a permissions issue. Check:\")\n",
-    "                print(\"   1. Is the service account enabled?\")\n",
-    "                print(\"   2. Does it have the right permissions?\")\n",
-    "                print(\"   3. Is the Google Drive API enabled in your project?\")\n",
-    "            return False\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error making API call: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def test_file_listing(self):\n",
-    "        \"\"\"Test different file listing approaches\"\"\"\n",
-    "        print(\"\\n📁 Testing File Listing...\")\n",
-    "        print(\"-\" * 40)\n",
-    "        \n",
-    "        if not self.drive_service:\n",
-    "            print(\"❌ No Drive service available\")\n",
-    "            return False\n",
-    "        \n",
-    "        # Test 1: List any files (not just folders)\n",
-    "        try:\n",
-    "            print(\"Test 1: Listing all files (including documents)...\")\n",
-    "            results = self.drive_service.files().list(\n",
-    "                q=\"trashed=false\",\n",
-    "                fields=\"files(id, name, mimeType)\",\n",
-    "                pageSize=10\n",
-    "            ).execute()\n",
-    "            \n",
-    "            files = results.get('files', [])\n",
-    "            print(f\"✅ Found {len(files)} files total\")\n",
-    "            \n",
-    "            if files:\n",
-    "                print(\"📄 First few files:\")\n",
-    "                for file in files[:5]:\n",
-    "                    print(f\"   - {file['name']} ({file['mimeType']})\")\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error listing files: {e}\")\n",
-    "            return False\n",
-    "        \n",
-    "        # Test 2: List only folders\n",
-    "        try:\n",
-    "            print(f\"\\nTest 2: Listing folders only...\")\n",
-    "            results = self.drive_service.files().list(\n",
-    "                q=\"mimeType='application/vnd.google-apps.folder' and trashed=false\",\n",
-    "                fields=\"files(id, name, parents)\",\n",
-    "                pageSize=10\n",
-    "            ).execute()\n",
-    "            \n",
-    "            folders = results.get('files', [])\n",
-    "            print(f\"✅ Found {len(folders)} folders\")\n",
-    "            \n",
-    "            if folders:\n",
-    "                print(\"📁 Folders found:\")\n",
-    "                for folder in folders:\n",
-    "                    print(f\"   - {folder['name']} (ID: {folder['id']})\")\n",
-    "            else:\n",
-    "                print(\"⚠️ No folders found - this might indicate:\")\n",
-    "                print(\"   1. Your Google Drive is empty\")\n",
-    "                print(\"   2. The service account doesn't have access to your personal Drive\")\n",
-    "                print(\"   3. You need to share folders with the service account\")\n",
-    "            \n",
-    "            return len(folders) > 0\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error listing folders: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def test_root_access(self):\n",
-    "        \"\"\"Test access to root folder\"\"\"\n",
-    "        print(\"\\n🏠 Testing Root Folder Access...\")\n",
-    "        print(\"-\" * 40)\n",
-    "        \n",
-    "        try:\n",
-    "            if not self.drive_service:\n",
-    "                print(\"❌ No Drive service available\")\n",
-    "                return False\n",
-    "            \n",
-    "            # Try to get root folder info\n",
-    "            root_info = self.drive_service.files().get(\n",
-    "                fileId='root',\n",
-    "                fields=\"id, name, mimeType\"\n",
-    "            ).execute()\n",
-    "            \n",
-    "            print(f\"✅ Root folder accessible\")\n",
-    "            print(f\"📁 Root folder name: {root_info.get('name', 'My Drive')}\")\n",
-    "            \n",
-    "            # Try to list contents of root\n",
-    "            results = self.drive_service.files().list(\n",
-    "                q=\"'root' in parents and trashed=false\",\n",
-    "                fields=\"files(id, name, mimeType)\",\n",
-    "                pageSize=10\n",
-    "            ).execute()\n",
-    "            \n",
-    "            root_contents = results.get('files', [])\n",
-    "            print(f\"📄 Items in root folder: {len(root_contents)}\")\n",
-    "            \n",
-    "            if root_contents:\n",
-    "                print(\"🔍 Root folder contents:\")\n",
-    "                for item in root_contents[:5]:\n",
-    "                    item_type = \"📁\" if \"folder\" in item['mimeType'] else \"📄\"\n",
-    "                    print(f\"   {item_type} {item['name']}\")\n",
-    "            \n",
-    "            return True\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Error accessing root folder: {e}\")\n",
-    "            return False\n",
-    "    \n",
-    "    def run_full_diagnostic(self):\n",
-    "        \"\"\"Run complete diagnostic\"\"\"\n",
-    "        print(\"🚀 Google Drive API Diagnostic Tool\")\n",
-    "        print(\"=\" * 50)\n",
-    "        \n",
-    "        # Step 1: Environment variables\n",
-    "        if not self.test_environment_variables():\n",
-    "            print(\"\\n❌ Environment setup failed. Please check your service account file.\")\n",
-    "            return False\n",
-    "        \n",
-    "        # Step 2: Credentials\n",
-    "        if not self.test_credentials_loading():\n",
-    "            print(\"\\n❌ Credentials loading failed.\")\n",
-    "            return False\n",
-    "        \n",
-    "        # Step 3: Service creation\n",
-    "        if not self.test_drive_service_creation():\n",
-    "            print(\"\\n❌ Drive service creation failed.\")\n",
-    "            return False\n",
-    "        \n",
-    "        # Step 4: Basic API call\n",
-    "        if not self.test_basic_api_call():\n",
-    "            print(\"\\n❌ Basic API call failed.\")\n",
-    "            return False\n",
-    "        \n",
-    "        # Step 5: Root access\n",
-    "        if not self.test_root_access():\n",
-    "            print(\"\\n❌ Root folder access failed.\")\n",
-    "            return False\n",
-    "        \n",
-    "        # Step 6: File listing\n",
-    "        if not self.test_file_listing():\n",
-    "            print(\"\\n❌ File listing failed or no folders found.\")\n",
-    "            print(\"\\n🔧 SOLUTION SUGGESTIONS:\")\n",
-    "            print(\"1. If you're using a service account, you need to SHARE folders with it\")\n",
-    "            print(\"2. Share your 'Blue Berry' folder with the service account email\")\n",
-    "            print(\"3. Or consider using OAuth2 instead of service account for personal Drive access\")\n",
-    "            return False\n",
-    "        \n",
-    "        print(\"\\n✅ All diagnostic tests passed!\")\n",
-    "        print(\"🎉 Your Google Drive API connection is working correctly!\")\n",
-    "        return True\n",
-    "    \n",
-    "    def show_service_account_sharing_instructions(self):\n",
-    "        \"\"\"Show instructions for sharing with service account\"\"\"\n",
-    "        print(\"\\n📋 SERVICE ACCOUNT SHARING INSTRUCTIONS:\")\n",
-    "        print(\"=\" * 50)\n",
-    "        print(\"If you're using a service account, you need to share folders with it:\")\n",
-    "        print()\n",
-    "        print(\"1. Open Google Drive in your browser\")\n",
-    "        print(\"2. Find the folder you want to access (e.g., 'Blue Berry')\")\n",
-    "        print(\"3. Right-click the folder → 'Share'\")\n",
-    "        print(\"4. Add the service account email address\")\n",
-    "        print(\"5. Give it 'Viewer' or 'Editor' permissions\")\n",
-    "        print(\"6. Click 'Send'\")\n",
-    "        print()\n",
-    "        \n",
-    "        if self.credentials:\n",
-    "            try:\n",
-    "                service_account_file = os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE')\n",
-    "                with open(service_account_file, 'r') as f:\n",
-    "                    service_data = json.load(f)\n",
-    "                email = service_data.get('client_email')\n",
-    "                print(f\"📧 Your service account email: {email}\")\n",
-    "                print(\"   ^ Share your folders with this email address\")\n",
-    "            except:\n",
-    "                print(\"❌ Could not read service account email\")\n",
-    "\n",
-    "def main():\n",
-    "    diagnostic = DriveConnectionDiagnostic()\n",
-    "    success = diagnostic.run_full_diagnostic()\n",
-    "    \n",
-    "    if not success:\n",
-    "        diagnostic.show_service_account_sharing_instructions()\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    main()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e3374b17-d2fa-4c80-a70b-76b8bf94c702",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.13.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

RAG/.ipynb_checkpoints/rag-system-463320-f292991d0516-checkpoint.json

@@ -1,13 +0,0 @@
-{
-  "type": "service_account",
-  "project_id": "rag-system-463320",
-  "private_key_id": "f292991d051639790555548b3142cf9447594bee",
-  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCaIHHexQcwmlEx\n/68EK7q8RGtLGVVubssDFzw9eiCjBh71PNhpaXBj0RiwKtnmCrfuYZ0RHm1OQN1l\niiXE7eiRuDkgmhfuLx4k8+L7tBfEcpVA9HHEZXKpp1YHUnuDsS4UZWZDlc/Q/O6q\njt5xwcKpnDMYsOTVXSuj6NslzVmYQYgW3xAastKUzAr3N/zXnH4rvnCS9N2QocC7\nZ8Z+dQYLd4QG2Pty7Oe/FVCdPWM9HfT9MmdBDeJfxran3Wni+TXBqH9NWJsMVnAl\nLkix6iFuBGaGBKQwEmX5GwN59ILb26U8hcOgwrbVVqZS4CKEH4sodcDlsf6iPXbr\nJVGeBLUZAgMBAAECggEAAOK89MfS9rKX4TCCO+ifwbNSSWkjeEPTSEcZEj7s66Sw\nFWlAC5DO08+ShVvBrngE91irepBRCCdeDI9GLJ967bdx6XxwUVJcjO3sTkc08N6P\neco/mVdFdVuR30SRBQdwkktSp/RwDMnma6e3TWtFktNkBVWxH2XgR5o+IJkYjjXQ\nWfZhrqzAZ6d7519KbP1SKP210IAsst6FpS2lQf4JYu/ohn1G9Pf1PVDkZQ0PnAjB\noDMumBjrJJj4yupVu0nDAErQRp7eePfE5AXHtEHPKCmWQGVUq9e0T0xd/vILeSPl\nyO6UfS5vM5KvBiHouENkF7x27h+z+Uv+PZGP+wgDgQKBgQDVUc/Mq6Ef49vJtB+g\nPIX7o1wNupxlC1i2Yxfbsqtd09ZGTLfBoK2IJkj2K1kEUJoBEdw+iNhumbafH7Wp\n/k05xChIva2dsxtBqyxae4hak2SmZEIfXCpWxocXa8E9pVst68XZfcAAlWPqfjkT\nJkeYsbraOL+LTzBn+PFU1j7PYQKBgQC49sl9s+G4wnX5dTBKSerKhluR3luB5N2+\ndG/ySvbno+yuQcKWveARRxBMSMwrH3lr2UPe0KIfs2ez6ZMMskyy4X4qVS/RFkz9\nJdRYwZuJxYmHRYD9tGus70alfTxQOjcHYu4nP+BZ3/SYAS8IwQyJW0ZTJfb0GUHd\nSFzaIAfYuQKBgErs+GrwIaDc3LcFEFKsz3aqU0vzLrmC+b7eIWQmZnCHVmzMx4I4\nGJuIrvngEd0lHmKfzlcco8B9Nxq+/YTe8GsIzgl2rgOFBF7Va7fASg1eVeznrB3t\ntmVSR+LfEzm+2b7QYGba91R9JGIZwZxLRryIOJQreIPK5bqvQrzEn70hAoGBALIx\nf5jMze+T2NiFoApSABMxMdLsJ7iSZ1bvElKZChnMAV84F2Hmd5HtprP3hksdPXs7\ni3mEAk0MKCJaKsMWm3HScBwUicaj93QDF/qSO2iVmJNr0IObaAjpVGRmrM6V5yIE\nm2/QyDGN4zT2HvwOECfceXntn2c3Vg77ggjaxvRxAoGAGGXQBpyAnazkaC1vpstf\nFQwqINKGqClU9Q7ciAlDTJSbTT3q3HU5WiWZmJnxwHbd7GJN4dizypEf9g0/Zejb\nptZwejr3WB+6GwYWkabRxosVhsKBtaT/8NMmPtwZ1jEukZW4UbIAOziJ8OM/mhfm\ns3CDpUHWETb1X9bB3Jwljoc=\n-----END PRIVATE KEY-----\n",
-  "client_email": "rag-base@rag-system-463320.iam.gserviceaccount.com",
-  "client_id": "110051039758068935524",
-  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-  "token_uri": "https://oauth2.googleapis.com/token",
-  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
-  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/rag-base%40rag-system-463320.iam.gserviceaccount.com",
-  "universe_domain": "googleapis.com"
-}

RAG/app.py

@@ -1,140 +0,0 @@
-import GPTDriveIntegration
-import gradio as gr
-
-gpt_drive = GPTDriveIntegration()
-
-def process_user_query(query, search_terms_input):
-    """Process user query and return formatted response"""
-    if not query.strip():
-        return "Please enter a question.", ""
-    
-    # Parse search terms if provided
-    search_terms = None
-    # if search_terms_input.strip():
-    #     search_terms = [term.strip() for term in search_terms_input.split(',')]
-    
-    # Process the query
-    result = gpt_drive.process_query(query, search_terms)
-    
-    # Format the response
-    answer = result['answer']
-    sources = result['sources']
-    
-    sources_text = ""
-    if sources:
-        sources_text = "**Sources used:**\n" + "\n".join([f"• {source}" for source in sources])
-    
-    return answer, sources_text
-
-def check_setup():
-    """Check if the APIs are properly configured"""
-    status_messages = []
-    
-    # Check Google Drive API
-    if gpt_drive.drive_initialized:
-        status_messages.append("✅ Google Drive API: Connected")
-    else:
-        status_messages.append(f"❌ Google Drive API: {getattr(gpt_drive, 'drive_error', 'Not configured')}")
-    
-    # Check OpenAI API
-    if gpt_drive.openai_initialized:
-        status_messages.append("✅ OpenAI API: Connected")
-    else:
-        status_messages.append(f"❌ OpenAI API: {getattr(gpt_drive, 'openai_error', 'Not configured')}")
-    
-    return "\n".join(status_messages)
-
-# Create Gradio interface
-with gr.Blocks(title="Augusta's Anatomy Reading Assistant", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🤖 Augusta's Anatomy bot")
-    gr.Markdown("Ask questions about your anatomy books using AI!")
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            # Main query interface
-            with gr.Group():
-                gr.Markdown("### Ask a Question")
-                query_input = gr.Textbox(
-                    label="Your Question",
-                    placeholder="Ask me any question about your anatomy books?",
-                    lines=3
-                )
-                
-                search_terms_input = gr.Textbox(
-                    label="Search Terms (optional)",
-                    placeholder="Enter comma-separated terms to search for specific files",
-                    lines=1
-                )
-                
-                submit_btn = gr.Button("Search & Ask", variant="primary", size="lg")
-            
-            # Results section
-            with gr.Group():
-                gr.Markdown("### Answer")
-                answer_output = gr.Textbox(
-                    label="AI Response",
-                    lines=10,
-                    interactive=False
-                )
-                
-                sources_output = gr.Textbox(
-                    label="Sources",
-                    lines=3,
-                    interactive=False
-                )
-        
-        with gr.Column(scale=1):
-            # Status and setup info
-            with gr.Group():
-                gr.Markdown("### System Status")
-                status_btn = gr.Button("Check Status", size="sm")
-                status_output = gr.Textbox(
-                    label="API Status",
-                    lines=4,
-                    interactive=False
-                )
-            
-            with gr.Group():
-                gr.Markdown("### Setup Instructions")
-                gr.Markdown("""
-                **Important Notes:**
-                1.Only documents shared with it, it can answer
-                
-                **File Types Supported:**
-                - Google Docs
-                - Google Sheets  
-                - PDF files
-                - Text files
-                
-                **Tips:**
-                - Use specific search terms for better results
-                - The system searches the top 3 most relevant files
-                - Ask clear, specific questions for better answers
-                """)
-    
-    # Event handlers
-    submit_btn.click(
-        fn=process_user_query,
-        inputs=[query_input, search_terms_input],
-        outputs=[answer_output, sources_output]
-    )
-    
-    status_btn.click(
-        fn=check_setup,
-        outputs=status_output
-    )
-    
-    # Example queries
-    with gr.Row():
-        gr.Examples(
-            examples=[
-                ["What is morbid Anatomy?", "morbid, Anatomy"],
-                ["The transmission of nerves from one neuron to another is as a result of what?", "neuron, nerves, Dr Clement"],
-            ],
-            inputs=[query_input, search_terms_input],
-        )
-
-# Launch the app
-if __name__ == "__main__":
-    app.launch(
-        share=True,debug =True)

RAG/rag-system-463320-f292991d0516.json

@@ -1,13 +0,0 @@
-{
-  "type": "service_account",
-  "project_id": "rag-system-463320",
-  "private_key_id": "f292991d051639790555548b3142cf9447594bee",
-  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCaIHHexQcwmlEx\n/68EK7q8RGtLGVVubssDFzw9eiCjBh71PNhpaXBj0RiwKtnmCrfuYZ0RHm1OQN1l\niiXE7eiRuDkgmhfuLx4k8+L7tBfEcpVA9HHEZXKpp1YHUnuDsS4UZWZDlc/Q/O6q\njt5xwcKpnDMYsOTVXSuj6NslzVmYQYgW3xAastKUzAr3N/zXnH4rvnCS9N2QocC7\nZ8Z+dQYLd4QG2Pty7Oe/FVCdPWM9HfT9MmdBDeJfxran3Wni+TXBqH9NWJsMVnAl\nLkix6iFuBGaGBKQwEmX5GwN59ILb26U8hcOgwrbVVqZS4CKEH4sodcDlsf6iPXbr\nJVGeBLUZAgMBAAECggEAAOK89MfS9rKX4TCCO+ifwbNSSWkjeEPTSEcZEj7s66Sw\nFWlAC5DO08+ShVvBrngE91irepBRCCdeDI9GLJ967bdx6XxwUVJcjO3sTkc08N6P\neco/mVdFdVuR30SRBQdwkktSp/RwDMnma6e3TWtFktNkBVWxH2XgR5o+IJkYjjXQ\nWfZhrqzAZ6d7519KbP1SKP210IAsst6FpS2lQf4JYu/ohn1G9Pf1PVDkZQ0PnAjB\noDMumBjrJJj4yupVu0nDAErQRp7eePfE5AXHtEHPKCmWQGVUq9e0T0xd/vILeSPl\nyO6UfS5vM5KvBiHouENkF7x27h+z+Uv+PZGP+wgDgQKBgQDVUc/Mq6Ef49vJtB+g\nPIX7o1wNupxlC1i2Yxfbsqtd09ZGTLfBoK2IJkj2K1kEUJoBEdw+iNhumbafH7Wp\n/k05xChIva2dsxtBqyxae4hak2SmZEIfXCpWxocXa8E9pVst68XZfcAAlWPqfjkT\nJkeYsbraOL+LTzBn+PFU1j7PYQKBgQC49sl9s+G4wnX5dTBKSerKhluR3luB5N2+\ndG/ySvbno+yuQcKWveARRxBMSMwrH3lr2UPe0KIfs2ez6ZMMskyy4X4qVS/RFkz9\nJdRYwZuJxYmHRYD9tGus70alfTxQOjcHYu4nP+BZ3/SYAS8IwQyJW0ZTJfb0GUHd\nSFzaIAfYuQKBgErs+GrwIaDc3LcFEFKsz3aqU0vzLrmC+b7eIWQmZnCHVmzMx4I4\nGJuIrvngEd0lHmKfzlcco8B9Nxq+/YTe8GsIzgl2rgOFBF7Va7fASg1eVeznrB3t\ntmVSR+LfEzm+2b7QYGba91R9JGIZwZxLRryIOJQreIPK5bqvQrzEn70hAoGBALIx\nf5jMze+T2NiFoApSABMxMdLsJ7iSZ1bvElKZChnMAV84F2Hmd5HtprP3hksdPXs7\ni3mEAk0MKCJaKsMWm3HScBwUicaj93QDF/qSO2iVmJNr0IObaAjpVGRmrM6V5yIE\nm2/QyDGN4zT2HvwOECfceXntn2c3Vg77ggjaxvRxAoGAGGXQBpyAnazkaC1vpstf\nFQwqINKGqClU9Q7ciAlDTJSbTT3q3HU5WiWZmJnxwHbd7GJN4dizypEf9g0/Zejb\nptZwejr3WB+6GwYWkabRxosVhsKBtaT/8NMmPtwZ1jEukZW4UbIAOziJ8OM/mhfm\ns3CDpUHWETb1X9bB3Jwljoc=\n-----END PRIVATE KEY-----\n",
-  "client_email": "rag-base@rag-system-463320.iam.gserviceaccount.com",
-  "client_id": "110051039758068935524",
-  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-  "token_uri": "https://oauth2.googleapis.com/token",
-  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
-  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/rag-base%40rag-system-463320.iam.gserviceaccount.com",
-  "universe_domain": "googleapis.com"
-}

RAG/requirements.txt

@@ -1,9 +0,0 @@
-google-api-python-client
-google-auth 
-openai 
-python-dotenv 
-chromadb 
-sentence-transformers 
-numpy
-gradio
-flask