Metadata-Version: 2.1
Name: minio-weaviate-langchain
Version: 0.1.0
Summary: A FastAPI application with Langchain, Weaviate, and MinIO integrations
Home-page: https://github.com/Cdaprod/minio-weaviate-langchain
Author: David Cannan
Author-email: cdaprod@cdaprod.dev
License: UNKNOWN
Description: This will guide users on how to deploy the application using Docker, which simplifies the setup process by handling dependencies and configurations through Docker containers. Here's an updated version of the `README.md` with Docker Compose deployment instructions:
        
        ### README.md
        
        # My FastAPI Application with Langchain, Weaviate, and MinIO Integrations
        
        This FastAPI application demonstrates an integrated text processing pipeline using Weaviate and MinIO. It's designed to efficiently process, store, and retrieve documents through a Dockerized environment.
        
        ## Features
        
        - Process documents from a MinIO bucket.
        - Use OpenAI's LangChain for advanced text processing.
        - Index and manage documents in Weaviate.
        - Easy deployment with Docker Compose.
        
        ## Requirements
        
        - Docker
        - Docker Compose
        
        ## Installation and Deployment
        
        1. **Clone the Repository**:
        
            ```bash
            git clone https://github.com/Cdaprod/minio-weaviate-langchain
            cd minio-weaviate-langchain
            ```
        
        2. **Start the Application with Docker Compose**:
        
            Run the following command to start all services defined in your `docker-compose.yaml`:
        
            ```bash
            docker-compose up
            ```
        
            This command will build and start containers for your FastAPI app, Weaviate, and MinIO.
        
        ## Proof of Concept
        
        The application showcases the following workflow:
        
        1. **Load Documents from MinIO**: The application retrieves documents stored in a MinIO bucket.
        
        2. **Document Processing**: Documents are processed via LangChain's OpenAI integration.
        
        3. **Indexing in Weaviate**: Processed documents are indexed in Weaviate for full-text search and data retrieval.
        
        4. **API Endpoints**:
            - `POST /process_documents`: Processes and indexes documents from MinIO into Weaviate.
            - `GET /`: Health check endpoint.
            - `POST /index_from_minio`: Indexes documents from MinIO into Weaviate.
            - `POST /query`: Queries documents in Weaviate.
            - `POST /update/{uuid}`: Updates a document in Weaviate.
            - `DELETE /delete/{uuid}`: Deletes a document from Weaviate.
        
        ## Example Usage
        
        - **Index Documents from MinIO**:
        
            ```python
            import requests
            response = requests.post('http://localhost:8000/index_from_minio')
            print(response.json())
            ```
        
        - **Query Documents in Weaviate**:
        
            ```python
            query = '{"query": "your_query_here"}'
            response = requests.post('http://localhost:8000/query', json=query)
            print(response.json())
            ```
        
        ## Contributing
        
        Contributions are welcome! Fork the repository, make your changes, and submit a pull request.
        
        ## Further Development for Notebook Environment
        
        To adapt your FastAPI application with Weaviate and MinIO integration for use in a Jupyter notebook, you'll need to structure it as a Python package that can be installed and used interactively. The structure of the package should facilitate easy installation and usage within a notebook environment. 
        
        Here's a basic outline of steps to restructure your application:
        
        ### 1. Organize Your Application as a Package
        
        Your project directory might look something like this:
        
        ```
        minio-weaviate-langchain/
            my_fastapi_lib/
                __init__.py
                main.py
                weaviate_operations.py
                minio_operations.py
                # ... other modules ...
            setup.py
            README.md
            LICENSE
        ```
        
        In `minio-weaviate-langchain/my_fastapi_lib/__init__.py`, you can import the main components:
        
        ```python
        from .main import app
        from .weaviate_operations import WeaviateOperations
        from .minio_operations import load_documents_from_minio
        ```
        
        ### 2. Setup.py for Installation
        
        Your `setup.py` allows the package to be installed via pip. Here's an example:
        
        ```python
        from setuptools import setup, find_packages
        
        setup(
            name='my_fastapi_lib',
            version='0.1.0',
            packages=find_packages(),
            include_package_data=True,
            install_requires=[
                'fastapi',
                'uvicorn',
                'weaviate-client',
                'minio',
                'langchain',
                # ... other dependencies ...
            ],
        )
        ```
        
        ### 3. Using the Library in a Jupyter Notebook
        
        Once your library is structured and installable, you can create a Jupyter notebook to demonstrate its usage. For example:
        
        #### Cell 1: Install the library
        
        ```python
        !pip install git+https://github.com/yourusername/my_fastapi_lib.git
        ```
        
        #### Cell 2: Import and Initialize Components
        
        ```python
        from my_fastapi_lib import WeaviateOperations, load_documents_from_minio
        
        # Setup Weaviate and MinIO clients
        weaviate_ops = WeaviateOperations(WEAVIATE_ENDPOINT)
        minio_documents = load_documents_from_minio(MINIO_BUCKET, MINIO_ENDPOINT, MINIO_ACCESS_KEY, MINIO_SECRET_KEY)
        ```
        
        #### Cell 3: Use the Library
        
        ```python
        # Example operation
        for doc in minio_documents:
            processed_doc = process_document(doc)  # Define this function as per your processing logic
            weaviate_ops.index_document(MINIO_BUCKET, "DocumentName", processed_doc)
        ```
        
        ### 4. Documentation and Examples
        
        Provide clear instructions and examples in your `README.md` and include Jupyter notebooks that demonstrate the use of your library.
        
        ### 5. Running the FastAPI App
        
        Since the FastAPI app is designed to be run as a server, it might not be directly applicable in a Jupyter notebook for interactive use. Instead, focus on demonstrating how to interact with the server (which could be running locally or remotely) using requests or similar in the notebook.
        
        ### Note
        
        Adapting a FastAPI application for use as a library in a Jupyter notebook involves a shift in focus. The interactive notebook environment is more suited for demonstrating API calls to the running FastAPI server, rather than running the server itself within the notebook.
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Framework :: FastAPI
Requires-Python: >=3.6
Description-Content-Type: text/markdown
