Metadata-Version: 2.1
Name: gptdeploy
Version: 0.1.0
Summary: Use natural language interface to create, deploy and update your microservice infrastructure.
Home-page: https://github.com/jina-ai/gptdeploy
Author: Florian Hönicke
Author-email: florian.hoenicke@jina.ai
License: UNKNOWN
Description: 
        
        # 🤖 GPT Deploy
        This project streamlines the creation and deployment of microservices. 
        Simply describe your task using natural language, and the system will automatically build and deploy your microservice. 
        To ensure the executor accurately aligns with your intended task, you can also provide test scenarios.
        
        # Quickstart
        ## install
        ```bash
        pip install gptdeploy
        ```
        
        ## run
        ```bash
        gptdeploy --description "Take a pdf file as input, and returns the text it contains." \
        --test "Takes https://www2.deloitte.com/content/dam/Deloitte/de/Documents/about-deloitte/Deloitte-Unternehmensgeschichte.pdf and returns a string that is at least 100 characters long"
        ```
        
        
        # Overview
        The graphic below illustrates the process of creating a microservice and deploying it to the cloud.
        ```mermaid
        graph TB
            A[User Input: Task Description & Test Scenarios] --> B{GPT Deploy}
            B -->|Identify Strategies| C[Strategy 1]
            B -->|Identify Strategies| D[Strategy 2]
            B -->|Identify Strategies| E[Strategy N]
            C --> F[executor.py, test_executor.py, requirements.txt, Dockerfile]
            D --> G[executor.py, test_executor.py, requirements.txt, Dockerfile]
            E --> H[executor.py, test_executor.py, requirements.txt, Dockerfile]
            F --> I{Build Image}
            G --> I
            H --> I
            I -->|Fail| J[Apply Fix and Retry]
            J --> I
            I -->|Success| K[Push Docker Image to Registry]
            K --> L[Deploy Microservice]
            L --> M[Create Streamlit Playground]
            M --> N[User Tests Microservice]
        ```
        1. GPT Deploy identifies several strategies to implement your task.
        2. It tests each strategy until it finds one that works.
        3. For each strategy, it creates the following files:
        - executor.py: This is the main implementation of the microservice.
        - test_executor.py: These are test cases to ensure the microservice works as expected.
        - requirements.txt: This file lists the packages needed by the microservice and its tests.
        - Dockerfile: This file is used to run the microservice in a container and also runs the tests when building the image.
        4. GPT Deploy attempts to build the image. If the build fails, it uses the error message to apply a fix and tries again to build the image.
        5. Once it finds a successful strategy, it:
        - Pushes the Docker image to the registry.
        - Deploys the microservice.
        - Creates a Streamlit playground where you can test the microservice.
        6. If it fails 10 times in a row, it moves on to the next approach.
        
        # 🤏 limitations for now
        - stateless microservices only
        - deterministic microservices only to make sure input and output pairs can be used
        
        # 🔮 vision
        Use natural language interface to create, deploy and update your microservice infrastructure.
        
        
        [//]: # ([![Watch the video]&#40;https://i.imgur.com/vKb2F1B.png&#41;]&#40;https://user-images.githubusercontent.com/11627845/226220484-17810f7c-b184-4a03-9af2-3a977fbb014b.mov&#41;)
        
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Description-Content-Type: text/markdown
