Upload 6 files

.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

Dockerfile

@@ -0,0 +1,18 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Set the working directory in the container
+WORKDIR /code
+
+# Copy the requirements file into the container
+COPY ./requirements.txt /code/requirements.txt
+
+# Install the packages specified in requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# Copy the rest of your application's code into the container
+COPY . /code/
+
+# Command to run the application.
+# Hugging Face Spaces expects the app to run on port 7860.
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adarsh Jha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,201 @@
 ---
-title: Intelligent Document QNA Api
-emoji: 🏆
-colorFrom: green
-colorTo: blue
+title: Intelligent Document QnA API
+emoji: 📚
+colorFrom: blue
+colorTo: green
 sdk: docker
-pinned: false
-license: mit
-short_description: A high-performance API that allows you to find answers withi
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Intelligent Document Q&A API
+[![Status](https://img.shields.io/badge/status-complete-brightgreen)](#)
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](#)
+[![Framework](https://img.shields.io/badge/framework-FastAPI-blue)](#)
+[![LangChain](https://img.shields.io/badge/LangChain-enabled-yellow)](#)
+[![PostgreSQL](https://img.shields.io/badge/db-Supabase%20%2B%20pgvector-009688)](#)
+[![Model](https://img.shields.io/badge/AI-GeminiAI%20%2B%20GoogleAI-orange)](#)
+
+
+A high-performance API that allows you to find answers within your documents using powerful language models. Ingest PDFs, DOCX files, or emails, and get back precise answers to your questions.
+
+This project is designed to be simple to set up and use, acting as a robust backend for any application that needs document-based question-answering capabilities.
+
+---
+
+### 🚀 What Makes This Project Different?
+
+Unlike many existing RAG APIs, this project is:
+
+- **Model-Agnostic and Multi-Provider Friendly**  
+  Supports both **Google Gemini** and **Gemini AI** out of the box — no hard dependency on OpenAI.
+
+- **Cloud-Ready and Free-Tier Optimized**  
+  Specifically engineered to run smoothly on platforms like **Render**, with memory-efficient caching and lazy model loading.
+
+- **Format-Intelligent**  
+  Automatically detects and uses the correct loader for `.pdf`, `.docx`, and `.eml` files — no manual preprocessing required.
+
+- **Minimal Memory Footprint**  
+  Designed for low-resource environments — ideal for free-tier deployments, research prototypes, or student projects.
+
+- **Clean JSON Output**  
+  Filters out verbose LLM reasoning ("Thought: Let's find the answer...") and returns only the clean, relevant answers.
+
+This makes it ideal for developers, students, and startups looking to build document Q&A apps without the complexity or cost of large RAG systems.
+
+---
+
+## ✨ Features
+
+- **Multi-Format Support**  
+  Natively handles `.pdf`, `.docx`, and `.eml` files.
+
+- **Persistent Storage**  
+  Uses **Supabase** with `pgvector` to store document embeddings. Process a document once and query it instantly anytime after.
+
+- **High-Quality Answers**  
+  Leverages state-of-the-art language models from **Gemini AI** and **Google** for accurate embeddings and intelligent Q&A.
+
+- **Asynchronous & Fast**  
+  Built with **FastAPI** for high-performance, non-blocking I/O.
+
+- **Easy to Deploy**  
+  Ready to be containerized with **Docker** or deployed to any modern cloud platform.
+
+
+---
+
+## 🚀 Getting Started
+
+Follow these steps to get the API server running on your local machine.
+
+### ✅ Prerequisites
+
+- Python 3.8+
+- A Supabase account with a project created
+- API keys from Google AI Studio and Gemini AI
+
+---
+
+### 📁 1. Clone the Repository
+
+```bash
+git clone https://github.com/hacketthadwin/intelligent-document-qna-api.git
+cd intelligent-document-qna-api
+```
+
+---
+
+### 🗃️ 2. Set Up Your Supabase Database
+
+Enable the `vector` extension in your Supabase project:
+
+1. Go to your Supabase project dashboard  
+2. Navigate to the **SQL Editor**  
+3. Run the following SQL command:
+
+```sql
+create extension if not exists vector;
+```
+
+A `documents` table will be automatically created the first time a document is processed via LangChain.
+
+---
+
+### 🔐 3. Configure Environment Variables
+
+Create a `.env` file in the root of your project directory. Use this template:
+
+```env
+# --- Service Keys ---
+GOOGLE_API_KEY="your_google_api_key_here"
+# --- Supabase Credentials for Vector Store ---
+SUPABASE_URL="https://your_supabase_project_id.supabase.co"
+SUPABASE_SERVICE_KEY="your_supabase_service_role_key_here"
+```
+
+---
+
+### 📦 4. Install Dependencies
+
+Install required packages using pip:
+
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+### ▶️ 5. Run the API Server
+
+Start the FastAPI server with:
+
+```bash
+python -m uvicorn main:app --reload
+```
+
+Visit [http://127.0.0.1:8000](http://127.0.0.1:8000) to access the API.  
+Interactive docs available at [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs)
+
+---
+
+## ⚙️ API Usage
+
+### `POST /query`
+
+This endpoint ingests a document (if it's new) and answers questions about it.
+
+---
+
+### 📤 Request Body
+
+- `document_url` (string, required): Public URL to the document you want to query  
+- `questions` (array of strings, required): One or more questions to ask
+
+#### ✅ Example using `curl`
+
+```bash
+curl -X POST "http://127.0.0.1:8000/query" \
+-H "Content-Type: application/json" \
+-d '{
+  "document_url": "https://arxiv.org/pdf/1706.03762.pdf",
+  "questions": [
+    "What is the title of this paper?",
+    "Summarize the abstract in one sentence."
+  ]
+}'
+```
+
+---
+
+### 📥 Example Success Response
+
+```json
+{
+  "answers": [
+    "The title of the paper is 'Attention Is All You Need'.",
+    "The abstract introduces the Transformer, a new network architecture based solely on attention mechanisms that is more parallelizable and requires significantly less time to train than existing models."
+  ],
+  "document_url": "https://arxiv.org/pdf/1706.03762.pdf",
+  "message": "New document processed and vectors stored in database."
+}
+```
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! If you have ideas for features or improvements:
+
+- Open an issue to discuss  
+- Fork the repository  
+- Create a new branch  
+- Make your changes  
+- Submit a pull request
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License. See the [LICENSE](./LICENSE) file for more details.
+

app.py

@@ -0,0 +1,259 @@
+# To run this application:
+# 1. Make sure you have a .env file with your service keys (e.g., GOOGLE_API_KEY, SUPABASE_URL, TOGETHER_API_KEY, SUPABASE_SERVICE_KEY).
+# 2. Ensure your Supabase database is set up with the 'vector' extension.
+# 3. Install required packages: pip install -r requirements.txt
+# 4. Run the server: python -m uvicorn main:app --reload
+
+import os
+import tempfile
+import json
+import requests
+import asyncio
+import traceback
+from dotenv import load_dotenv
+from typing import List, Optional
+
+# --- FastAPI and Pydantic Imports ---
+from fastapi import FastAPI, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field, HttpUrl
+
+# --- Langchain and related imports ---
+from langchain_community.document_loaders import PyPDFLoader, Docx2txtLoader, UnstructuredEmailLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import SupabaseVectorStore
+from langchain_together import ChatTogether
+from langchain_google_genai import GoogleGenerativeAIEmbeddings, ChatGoogleGenerativeAI
+from langchain.chains import RetrievalQA
+from langchain.prompts import PromptTemplate
+from google.generativeai.types import HarmCategory, HarmBlockThreshold
+
+# --- Supabase Imports ---
+from supabase.client import Client, create_client
+
+# --- 1. INITIALIZATION & CONFIGURATION ---
+
+load_dotenv()
+GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+SUPABASE_URL = os.environ.get("SUPABASE_URL")
+SUPABASE_SERVICE_KEY = os.environ.get("SUPABASE_SERVICE_KEY")
+
+# --- FastAPI App Initialization ---
+app = FastAPI(
+    title="Intelligent Document Q&A API",
+    description="An API to find answers within documents (PDF, DOCX, EML). It ingests documents from a URL, stores them in a persistent vector database, and allows you to ask multiple questions.",
+    version="1.1.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Lazy Loading for Models and Clients ---
+llm: Optional[ChatTogether] = None
+gemini_embedder: Optional[GoogleGenerativeAIEmbeddings] = None
+supabase_client: Optional[Client] = None
+
+# --- 2. STARTUP EVENT ---
+
+@app.on_event("startup")
+async def startup_event():
+    """On application startup, initialize components."""
+    print("Application startup: Initializing components...")
+    initialize_components()
+
+def initialize_components():
+    """Initializes models and clients if they haven't been already."""
+    global llm, gemini_embedder, supabase_client
+    if llm is None:
+        print("Initializing Gemini AI LLM...")
+        llm = ChatGoogleGenerativeAI(model="gemini-pro", temperature=0.2, convert_system_message_to_human=True)
+    if gemini_embedder is None:
+        print("Initializing Google Gemini Embedding model...")
+        gemini_embedder = GoogleGenerativeAIEmbeddings(
+            model="models/embedding-001",
+            safety_settings={
+                HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+            }
+        )
+    if supabase_client is None and SUPABASE_URL and SUPABASE_SERVICE_KEY:
+        print("Initializing Supabase client...")
+        supabase_client = create_client(SUPABASE_URL, SUPABASE_SERVICE_KEY)
+    print("Models and clients are ready.")
+
+
+# --- Prompt Template for the LLM ---
+PROMPT_TEMPLATE = PromptTemplate(
+    template="""
+    **Your Role:** You are a helpful AI assistant. Your task is to answer the user's question based *only* on the provided document context.
+    **Strict Constraints:**
+    - Your answer **MUST** be derived solely from the `Document Context`. Do not use any external knowledge.
+    - If the answer is not in the context, state: "The answer to this question could not be found in the provided document."
+    ---
+    **Document Context:** {context}
+    ---
+    **User Query:** {question}
+    ---
+    **Helpful Answer:**
+    """,
+    input_variables=["question", "context"]
+)
+
+
+# --- Pydantic Models for Request and Response ---
+class QueryRequest(BaseModel):
+    document_url: HttpUrl = Field(..., description="A single public URL to a document (PDF, DOCX, EML).")
+    questions: List[str] = Field(..., min_length=1, description="A non-empty list of questions to ask about the document.")
+
+
+class QueryResponse(BaseModel):
+    answers: List[str]
+    document_url: HttpUrl
+    message: str
+
+
+# --- 3. CORE API ENDPOINT ---
+@app.post('/query', response_model=QueryResponse, tags=["Document Q&A"])
+async def query_document(payload: QueryRequest):
+    """
+    This endpoint ingests a document if new, then finds answers to questions within it.
+    - If a document has been processed before, it uses the cached version from the vector store.
+    - Otherwise, it downloads, processes, and stores the document for future queries.
+    """
+    print(f"\n--- New Request Received for /query ---")
+
+    if not supabase_client:
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Database client is not available. Check Supabase credentials.")
+
+    doc_url = str(payload.document_url)
+    questions = payload.questions
+    print(f"Processing document from URL: {doc_url}")
+    print(f"Answering {len(questions)} questions.")
+
+    vectorstore = None
+    ingestion_message = ""
+
+    try:
+        # --- Check for Existing Embeddings in Supabase ---
+        print("Step 1: Checking for existing document vectors in Supabase...")
+        response = supabase_client.from_("documents").select("id", count='exact').eq("metadata->>source", doc_url).limit(1).execute()
+
+        if response.count > 0:
+            print("DATABASE HIT: Found pre-processed vectors. Skipping ingestion.")
+            ingestion_message = "Document already processed. Using existing vectors from database."
+            vectorstore = SupabaseVectorStore(
+                client=supabase_client,
+                embedding=gemini_embedder,
+                table_name="documents",
+                query_name="match_documents"
+            )
+        else:
+            print("DATABASE MISS: Processing and embedding new document.")
+            ingestion_message = "New document processed and vectors stored in database."
+            temp_file_path = None
+            try:
+                print("Step 1a: Downloading document...")
+                http_response = requests.get(doc_url)
+                http_response.raise_for_status()
+
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".tmp") as temp_file:
+                    temp_file.write(http_response.content)
+                    temp_file_path = temp_file.name
+
+                lower_doc_url = doc_url.lower()
+                if lower_doc_url.endswith('.pdf'): loader = PyPDFLoader(temp_file_path)
+                elif lower_doc_url.endswith('.docx'): loader = Docx2txtLoader(temp_file_path)
+                elif lower_doc_url.endswith('.eml'): loader = UnstructuredEmailLoader(temp_file_path)
+                else: loader = PyPDFLoader(temp_file_path)
+
+                pages = loader.load()
+                if not pages: raise ValueError("Could not load content from the document.")
+                print(f"Step 2: Loaded {len(pages)} pages/sections.")
+
+                text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+                docs = text_splitter.split_documents(pages)
+                if not docs: raise ValueError("Document could not be split into processable chunks.")
+
+                for doc in docs:
+                    doc.metadata = {"source": doc_url}
+
+                print(f"Step 3: Split document into {len(docs)} chunks. Uploading to Supabase...")
+                vectorstore = await SupabaseVectorStore.afrom_documents(
+                    documents=docs,
+                    embedding=gemini_embedder,
+                    client=supabase_client,
+                    table_name="documents",
+                    query_name="match_documents",
+                    chunk_size=50
+                )
+                print("Step 4: Supabase vector store created successfully.")
+
+            finally:
+                if temp_file_path and os.path.exists(temp_file_path):
+                    os.remove(temp_file_path)
+                    print(f"Temporary file removed: {temp_file_path}")
+
+        # --- Create Retriever and QA Chain ---
+        retriever = vectorstore.as_retriever(search_kwargs={"k": 15, "filter": {"source": doc_url}})
+        print("Step 5: Initialized retriever with source document filter.")
+
+        qa_chain = RetrievalQA.from_chain_type(
+            llm=llm,
+            chain_type="stuff",
+            retriever=retriever,
+            return_source_documents=False,
+            chain_type_kwargs={"prompt": PROMPT_TEMPLATE}
+        )
+        print("Step 6: RAG QA Chain created.")
+
+    except Exception as e:
+        print(f"ERROR during document processing or vector store setup: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Failed to process document: {str(e)}")
+
+    # --- Question Answering ---
+    try:
+        async def get_answer(chain, query):
+            print(f"Processing query: '{query}'")
+            try:
+                result = await chain.ainvoke({"query": query})
+                answer = result.get('result', 'Error: Could not process this question.').strip()
+                print(f"Successfully answered: '{query}'")
+                return answer
+            except Exception as e:
+                error_message = f"Error for query '{query}': {str(e)}"
+                print(f"ERROR invoking chain: {error_message}")
+                traceback.print_exc()
+                return error_message
+
+        print(f"Step 7: Starting parallel processing for {len(questions)} questions...")
+        tasks = [get_answer(qa_chain, q) for q in questions]
+        answers = await asyncio.gather(*tasks)
+        print("All questions processed successfully.")
+
+        final_response = {
+            "answers": answers,
+            "document_url": doc_url,
+            "message": ingestion_message
+        }
+        print(f"Final response prepared: {json.dumps(final_response, indent=2)}")
+        return final_response
+
+    except Exception as e:
+        print(f"ERROR during question answering: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"An error occurred during question answering: {str(e)}")
+
+
+# --- Health Check Endpoint ---
+@app.get("/", tags=["General"])
+def read_root():
+    """A simple health check endpoint to confirm the API is running."""
+    return {"status": "ok", "name": "Intelligent Document Q&A API"}

requirements.txt

@@ -0,0 +1,17 @@
+fastapi
+uvicorn[standard]
+python-dotenv
+pydantic
+requests
+httpx
+langchain
+langchain-community
+langchain-together
+langchain-google-genai
+google-generativeai
+pypdf
+docx2txt
+unstructured-client
+unstructured[eml]
+supabase
+psycopg2-binary