agenta 0.1.0__tar.gz

agenta-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.1
+Name: agenta
+Version: 0.1.0
+Summary: 
+Author: Mahmoud Mabrouk
+Author-email: mahmoudmabrouk.mail@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: click (>=8.1.3,<9.0.0)
+Requires-Dist: docker (>=6.1.1,<7.0.0)
+Requires-Dist: fastapi (>=0.95.1,<0.96.0)
+Requires-Dist: ipdb (>=0.13.13,<0.14.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: questionary (>=1.10.0,<2.0.0)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Description-Content-Type: text/markdown
+
+# Agenta CLI tool.
+
+The Agenta CLI tool enables users to add new versions of their code to the Agenta platform, allowing them to be evaluated, compared to other versions, and deployed.
+Installation
+
+To install dependencies, run the following command:
+
+```poetry install```
+
+## Requirements
+You need to have docker installed to be able to use the cli locally. 
+
+## How does it work
+
+The CLI allows you to push in one command your projects for evaluation in the dashboard.
+
+You only need to modify your code very slightly by adding a decorator to your chat/ and ingest functions.
+
+Under the hood the cli packages your code into a docker container and send it to a registry.
+
+Later the dashboard spins off these containers and runs the benchmarks and evaluations over them.
+## Quickstart
+
+To enter the virtual environment, run the following command:
+
+```poetry shell```
+
+To init a new project and start from a simple template. Run the following command in an empty folder:
+
+```agenta init```
+
+Build your code and add it to the platform to be tested in the UI. This command builds a Docker image for the version and upload the container to the registry:
+
+```agenta add-variant```
+
+Start your code as a containarized service locally:
+
+```agenta start```
+
+
+## How to write code to be user in agenta
+
+To write code that can be used in Agenta, you need to structure your project as follows:
+
+### Project Structure
+The project folder should contain:
+1. A Python file named `app.py`
+2. A `requirements.txt` file with all the necessary dependencies for running your code
+
+### app.py
+
+The `app.py` file should have the following functions:
+0. import `agenta`
+1. A function named chat that is exposed using the `@agenta.post` decorator
+2. An optional function named ingest that is exposed using the `@agenta.post` decorator
+
+### Example Project Structure
+
+Here's an example of how your project folder might look:
+
+my_agenda_project/
+│
+├── app.py
+└── requirements.txt
+
+### Example app.py
+```python
+from agenta import post, get
+
+class ChatInput(BaseModel):
+    messages: List[str]
+
+class ChatOutput(BaseModel):
+    response: str
+
+@post
+def chat(input_data: ChatInput) -> ChatOutput:
+    # Your chat function implementation here
+    response = "Hello, World!"
+    return ChatOutput(response=response)
+
+class IngestInput(BaseModel):
+    data: List[str]
+
+class IngestOutput(BaseModel):
+    status: str
+
+@post
+def ingest(input_data: IngestInput) -> IngestOutput:
+    # Your ingest function implementation here (if needed)
+    status = "Data ingestion successful."
+    return IngestOutput(status=status)
+
+```
+## How to deal with secrets:
+- For now we are using a .env file to store secrets.
+- Create an .env file to store your secrets.
+- The .env file is built into the image and uploaded to the local registry. THIS IS NOT GOOD. WE WILL FIX IT ASAP.

agenta-0.1.0/README.md

@@ -0,0 +1,98 @@
+# Agenta CLI tool.
+
+The Agenta CLI tool enables users to add new versions of their code to the Agenta platform, allowing them to be evaluated, compared to other versions, and deployed.
+Installation
+
+To install dependencies, run the following command:
+
+```poetry install```
+
+## Requirements
+You need to have docker installed to be able to use the cli locally. 
+
+## How does it work
+
+The CLI allows you to push in one command your projects for evaluation in the dashboard.
+
+You only need to modify your code very slightly by adding a decorator to your chat/ and ingest functions.
+
+Under the hood the cli packages your code into a docker container and send it to a registry.
+
+Later the dashboard spins off these containers and runs the benchmarks and evaluations over them.
+## Quickstart
+
+To enter the virtual environment, run the following command:
+
+```poetry shell```
+
+To init a new project and start from a simple template. Run the following command in an empty folder:
+
+```agenta init```
+
+Build your code and add it to the platform to be tested in the UI. This command builds a Docker image for the version and upload the container to the registry:
+
+```agenta add-variant```
+
+Start your code as a containarized service locally:
+
+```agenta start```
+
+
+## How to write code to be user in agenta
+
+To write code that can be used in Agenta, you need to structure your project as follows:
+
+### Project Structure
+The project folder should contain:
+1. A Python file named `app.py`
+2. A `requirements.txt` file with all the necessary dependencies for running your code
+
+### app.py
+
+The `app.py` file should have the following functions:
+0. import `agenta`
+1. A function named chat that is exposed using the `@agenta.post` decorator
+2. An optional function named ingest that is exposed using the `@agenta.post` decorator
+
+### Example Project Structure
+
+Here's an example of how your project folder might look:
+
+my_agenda_project/
+│
+├── app.py
+└── requirements.txt
+
+### Example app.py
+```python
+from agenta import post, get
+
+class ChatInput(BaseModel):
+    messages: List[str]
+
+class ChatOutput(BaseModel):
+    response: str
+
+@post
+def chat(input_data: ChatInput) -> ChatOutput:
+    # Your chat function implementation here
+    response = "Hello, World!"
+    return ChatOutput(response=response)
+
+class IngestInput(BaseModel):
+    data: List[str]
+
+class IngestOutput(BaseModel):
+    status: str
+
+@post
+def ingest(input_data: IngestInput) -> IngestOutput:
+    # Your ingest function implementation here (if needed)
+    status = "Data ingestion successful."
+    return IngestOutput(status=status)
+
+```
+## How to deal with secrets:
+- For now we are using a .env file to store secrets.
+- Create an .env file to store your secrets.
+- The .env file is built into the image and uploaded to the local registry. THIS IS NOT GOOD. WE WILL FIX IT ASAP.

agenta-0.1.0/agenta/__init__.py

@@ -0,0 +1 @@
+from .agenta import post, get, TextParam, FloatParam

agenta-0.1.0/agenta/agenta.py

@@ -0,0 +1,109 @@
+import argparse
+import functools
+import inspect
+import os
+import sys
+from typing import Any, Callable, Optional
+
+from dotenv import load_dotenv
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI()
+
+origins = [
+    "http://localhost:3000",
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class TextParam(str):
+
+    @classmethod
+    def __modify_schema__(cls, field_schema):
+        field_schema.update({"x-parameter": "text"})
+
+
+class FloatParam(float):
+
+    @classmethod
+    def __modify_schema__(cls, field_schema):
+        field_schema.update({"x-parameter": "float"})
+
+
+def post(func: Callable[..., Any]):
+    load_dotenv()  # TODO: remove later when we have a better way to inject env variables
+    sig = inspect.signature(func)
+    func_params = sig.parameters
+
+    # find the optional parameters for the app
+    app_params = {name: param for name, param in func_params.items()
+                  if param.annotation in {TextParam, FloatParam}}
+    # find the default values for the optional parameters
+    for name, param in app_params.items():
+        default_value = param.default if param.default is not param.empty else None
+        app_params[name] = default_value
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        kwargs = {**app_params, **kwargs}
+        return func(*args, **kwargs)
+
+    new_params = []
+    for name, param in sig.parameters.items():
+        if name in app_params:
+            new_params.append(
+                inspect.Parameter(
+                    name,
+                    inspect.Parameter.KEYWORD_ONLY,
+                    default=app_params[name],
+                    annotation=Optional[param.annotation]
+
+                )
+            )
+        else:
+            new_params.append(param)
+
+    wrapper.__signature__ = sig.replace(parameters=new_params)
+
+    route = "/generate"
+    app.post(route)(wrapper)
+
+    # check if the module is being run as the main script
+    if os.path.splitext(os.path.basename(sys.argv[0]))[0] == os.path.splitext(os.path.basename(inspect.getfile(func)))[0]:
+        parser = argparse.ArgumentParser()
+        # add arguments to the command-line parser
+        for name, param in sig.parameters.items():
+            if name in app_params:
+                # For optional parameters, we add them as options
+                parser.add_argument(f"--{name}", type=type(param.default),
+                                    default=param.default)
+            else:
+                # For required parameters, we add them as arguments
+                parser.add_argument(name, type=param.annotation)
+
+        args = parser.parse_args()
+        print(func(**vars(args)))
+
+    return wrapper
+
+
+def get(func):
+    """get decorator
+
+    Arguments:
+        func -- _description_
+
+    Returns:
+        _description_
+    """
+    route = f"/{func.__name__}"
+    app.get(route)(func)
+    return func

agenta-0.1.0/agenta/cli.py

@@ -0,0 +1,168 @@
+import os
+import shutil
+import sys
+from pathlib import Path
+
+import click
+import questionary
+import toml
+from agenta.client import client
+from agenta.docker.docker_utils import build_and_upload_docker_image
+from docker.models.images import Image as DockerImage
+
+
+def add_variant(variant_name: str, app_folder: str) -> str:
+    """Add a new variant.
+    Returns the name of the variant. (useful for serve)"""
+    app_path = Path(app_folder)
+    config_file = app_path / 'config.toml'
+    if not config_file.exists():
+        click.echo("Please run agenta init first")
+        return None
+    else:
+        config = toml.load(config_file)
+        app_name = config['app-name']
+        if 'variants' not in config:
+            config['variants'] = []
+    app_file = app_path / 'app.py'
+    if not app_file.exists():
+        click.echo(click.style(f"No app.py exists! Please make sure you are in the right directory", fg='red'))
+        return None
+    env_file = app_path / '.env'
+    if not env_file.exists():
+        continue_without_env = questionary.confirm(
+            'No .env file found! Are you sure you handled the API keys needed in your application?\n Do you want to continue without it?').ask()
+        if not continue_without_env:
+            click.echo("Operation cancelled.")
+            sys.exit(0)
+
+    if not variant_name:
+        variant_name = questionary.text('Please enter the variant name').ask()
+
+    if variant_name in config['variants']:
+        overwrite = questionary.confirm(
+            'This variant already exists. Do you want to overwrite it?').ask()
+        if not overwrite:
+            click.echo("Operation cancelled.")
+            sys.exit(0)
+    else:
+        config['variants'].append(variant_name)
+    try:
+        docker_image: DockerImage = build_and_upload_docker_image(
+            folder=app_path, app_name=app_name, variant_name=variant_name)
+    except Exception as ex:
+        click.echo(click.style(f"Error while building image: {ex}", fg='red'))
+        return None
+    try:
+        client.add_variant_to_server(app_name, variant_name, docker_image)
+    except Exception as ex:
+        click.echo(click.style(f"Error while adding variant: {ex}", fg='red'))
+        return None
+    click.echo(click.style(f"Variant {variant_name} for App {app_name} added successfully", fg='green'))
+    # Last step us to save the config file
+    toml.dump(config, config_file.open('w'))
+    return variant_name
+
+
+def start_variant(variant_name: str, app_folder: str):
+    app_folder = Path(app_folder)
+    config_file = app_folder / 'config.toml'
+    if not config_file.exists():
+        click.echo("Please run agenta init first")
+        return
+    else:
+        config = toml.load(config_file)
+        app_name = config['app-name']
+        if 'variants' not in config:
+            click.echo("No variants found. Please add a variant first.")
+            return
+
+    if not variant_name:
+        variant_name = questionary.select(
+            'Please choose a variant',
+            choices=config['variants']
+        ).ask()
+
+    endpoint = client.start_variant(app_name, variant_name)
+    click.echo(
+        f"Started variant {variant_name} for App {app_name}. Endpoint: {endpoint}")
+
+
+@click.group()
+def cli():
+    pass
+
+
+@click.command(name='serve')
+@click.argument('app_folder', default='.')
+def serve_cli(app_folder: str):
+    """Add a variant and start its container."""
+    variant_name = add_variant(variant_name='', app_folder=app_folder)
+    if variant_name:  # otherwise we failed
+        start_variant(variant_name=variant_name, app_folder=app_folder)
+
+
+@click.command(name='add-variant')
+@click.argument('app_folder', default='.')
+@click.option('--variant_name', default='')
+def add_variant_cli(variant_name: str, app_folder: str):
+    return add_variant(variant_name, app_folder)
+
+
+@click.command()
+@click.option('--app_name', default='')
+def init(app_name: str):
+    """Initialize a new Agenta app with the template files."""
+    if not app_name:
+        app_name = questionary.text('Please enter the app name').ask()
+
+    config = {"app-name": app_name}
+    with open('config.toml', 'w') as config_file:
+        toml.dump(config, config_file)
+
+    # Ask for init option
+    init_option = questionary.select(
+        "How do you want to initialize your app?",
+        choices=['Blank App', 'From Template']
+    ).ask()
+
+    # If the user selected the second option, show a list of available templates
+    if init_option == 'From Template':
+        current_dir = Path.cwd()
+        template_dir = Path(__file__).parent / "templates"
+        templates = [folder.name for folder in template_dir.iterdir()
+                     if folder.is_dir()]
+        template_desc = [toml.load(
+            (template_dir / name / 'template.toml'))['short_desc'] for name in templates]
+
+        # Show the templates to the user
+        template = questionary.select(
+            "Which template do you want to use?",
+            choices=[questionary.Choice(title=f"{template} - {template_desc}", value=template)
+                     for template, template_desc in zip(templates, template_desc)]
+        ).ask()
+
+        # Copy the template files to the current directory
+        chosen_template_dir = template_dir / template
+        for file in chosen_template_dir.glob("*"):
+            if file.name != 'template.toml':
+                shutil.copy(file, current_dir / file.name)
+    click.echo("App initialized successfully")
+
+
+@click.command(name='start')
+@click.option('--variant_name', default=None)
+@click.argument('app_folder', default=".")
+def start_variant_cli(variant_name: str, app_folder: str):
+    """Start a variant."""
+    start_variant(variant_name, app_folder)
+
+
+# Add the commands to the CLI group
+cli.add_command(add_variant_cli)
+cli.add_command(init)
+cli.add_command(start_variant_cli)
+cli.add_command(serve_cli)
+
+if __name__ == '__main__':
+    cli()

agenta-0.1.0/agenta/client/Readme.md

@@ -0,0 +1,3 @@
+Client code to communicate with the backend.
+
+Currently the models are manually copied from the backend code. This needs to change.

agenta-0.1.0/agenta/client/api_models.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+
+
+class AppVariant(BaseModel):
+    app_name: str
+    variant_name: str
+    parameters: Optional[Dict[str, Any]]
+    previous_variant_name: Optional[str]
+
+
+class Image(BaseModel):
+    docker_id: str
+    tags: str
+
+
+class URI(BaseModel):
+    uri: str

agenta-0.1.0/agenta/client/client.py

@@ -0,0 +1,39 @@
+from agenta.client.api_models import AppVariant, Image
+from docker.models.images import Image as DockerImage
+import requests
+
+
+def add_variant_to_server(app_name: str, variant_name: str, docker_image: DockerImage):
+    """Adds a variant to the server.
+
+    Arguments:
+        app_name -- Name of the app
+        variant_name -- Name of the variant
+        image_name -- Name of the image
+    """
+    image: Image = Image(docker_id=docker_image.id,
+                         tags=f"{docker_image.tags[0]}")
+    app_variant: AppVariant = AppVariant(
+        app_name=app_name, variant_name=variant_name)
+    # TODO: save uri as a config
+    response = requests.post("http://localhost/api/app_variant/add/from_image/",
+                             json={"app_variant": app_variant.dict(), "image": image.dict()})
+    if response.status_code != 200:
+        raise Exception(
+            f"Request to add variant failed with status code {response.status_code}. Response: {response.text}")
+
+
+def start_variant(app_name: str, variant_name: str) -> str:
+    """Starts a container with the variant an expose its endpoint
+
+    Arguments:
+        app_name -- 
+        variant_name -- _description_
+
+    Returns:
+        The endpoint of the container
+    """
+    response = requests.post("http://localhost/api/app_variant/start/",
+                             json={"app_name": app_name, "variant_name": variant_name})
+    assert response.status_code == 200
+    return response.json()['uri']

agenta-0.1.0/agenta/config.py

@@ -0,0 +1,21 @@
+from pydantic import BaseSettings
+
+import os
+import toml
+from pathlib import Path
+# Load the settings from the .toml file
+toml_config = toml.load(f"{Path(__file__).parent}/config.toml")
+
+# Set the environment variables from the TOML configurations
+os.environ["DOCKER_REGISTRY_URL"] = toml_config["docker_registry_url"]
+os.environ["DATABASE_URL"] = toml_config["database_url"]
+os.environ["REGISTRY"] = toml_config["registry"]
+
+
+class Settings(BaseSettings):
+    docker_registry_url: str
+    database_url: str
+    registry: str
+
+
+settings = Settings()

agenta-0.1.0/agenta/config.toml

@@ -0,0 +1,3 @@
+docker_registry_url="127.0.0.1:5001"
+database_url="localhost:5432"
+registry="agenta-server"

agenta-0.1.0/agenta/docker/docker-assets/Dockerfile.template

@@ -0,0 +1,13 @@
+FROM python:3.8-slim
+
+WORKDIR /app
+
+COPY . .
+
+RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install fastapi uvicorn python-dotenv
+EXPOSE 80
+
+CMD ["python", "main.py"]
+# uvicorn agenta_backend.main:app --reload --host 0.0.0.0 --port 8881
+# TODO: add root_path as env variable and give it to the docker to solve the docs issue

agenta-0.1.0/agenta/docker/docker-assets/README.md

@@ -0,0 +1 @@
+The code here is just used when creating the template to dockerize the app. It is not part of the cli.

agenta-0.1.0/agenta/docker/docker-assets/main.py

@@ -0,0 +1,8 @@
+from uvicorn import run
+
+import agenta
+import app  # This will register the routes with the FastAPI application
+from dotenv import load_dotenv  # I∑mport the load_dotenv function
+
+if __name__ == "__main__":
+    run("agenta:app", host="0.0.0.0", port=80)

agenta-0.1.0/agenta/docker/docker_utils.py

@@ -0,0 +1,75 @@
+import os
+import shutil
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import docker
+from agenta.config import settings
+from docker.models.images import Image
+
+
+def create_dockerfile(out_folder: Path):
+    """Creates a dockerfile based on the template in the out_folder.
+
+    Arguments:
+        out_folder -- Folder in which to create the Dockerfile.
+    """
+    assert Path(out_folder).exists(), f"Folder {out_folder} does not exist."
+    dockerfile_template = Path(__file__).parent / \
+        "docker-assets" / "Dockerfile.template"
+    dockerfile_path = out_folder / "Dockerfile"
+    shutil.copy(dockerfile_template, dockerfile_path)
+    return dockerfile_path
+
+
+def build_and_upload_docker_image(folder: Path, variant_name: str, app_name: str) -> Image:
+    """Builds an image from the folder and returns the path
+
+    Arguments:
+        folder -- The folder containg the app code
+
+    Returns:
+        The image object
+    TODO: Check that the variant name does not exist
+    TODO: Deal with different app names (probably we need to look then at multiple tags)
+    TODO: Error handling
+    """
+    # Initialize Docker client
+    client = docker.from_env()
+
+    with TemporaryDirectory() as temp_dir:
+        # Create a Dockerfile for the app
+        # TODO: Later do this in the temp dir
+        dockerfile_path = create_dockerfile(folder)
+        shutil.copy(Path(__file__).parent.parent / "agenta.py", folder)
+        shutil.copy(Path(__file__).parent /
+                    "docker-assets" / "main.py", folder)
+
+        # Copy the app files to a temporary directory
+        shutil.copytree(folder, temp_dir, dirs_exist_ok=True)
+
+        # Build the Docker image
+        registry = settings.registry
+        tag = f"{registry}/{app_name.lower()}_{variant_name.lower()}:latest"
+        print("Building Docker image...")
+        try:
+            image, build_log = client.images.build(
+                path=temp_dir,
+                tag=tag,
+                rm=True  # Remove intermediate containers after a successful build
+            )
+        except docker.errors.BuildError as e:
+            print("Error building Docker image:\n", e)
+            raise e
+
+        # Print the build log
+        for line in build_log:
+            print(line)
+        # Upload the Docker image to the Agenta registry
+        print("Uploading Docker image...")
+        client.images.push(repository=f"{registry}", tag="latest")
+        print("Docker image uploaded successfully.")
+
+        # Clean up the temporary Dockerfile
+        dockerfile_path.unlink()
+    return image

agenta-0.1.0/agenta/templates/simple_prompt/README.md

@@ -0,0 +1,9 @@
+# Using this template
+
+Please make sure to create a `.env` file with your OpenAI API key before running the app.
+OPENAI_API_KEY=sk-xxxxxxx
+
+## Running
+You can first test your app locally by using by running `python app.py`, after experimenting, send it to evaluation by running `agenta up folder`.
+You will find then the app in the dashboard, where you can evaluate it and compare it to previous versions.
+

agenta-0.1.0/agenta/templates/simple_prompt/app.py

@@ -0,0 +1,20 @@
+from agenta import post, TextParam, FloatParam
+from dotenv import load_dotenv
+from langchain.chains import LLMChain
+from langchain.llms import OpenAI
+from langchain.prompts import PromptTemplate
+
+default_prompt = "What is a good name for a company that makes {product}?"
+
+
+@post
+def generate(product: str, temperature: FloatParam = 0.9, prompt_template: TextParam = default_prompt) -> str:
+    llm = OpenAI(temperature=temperature)
+    prompt = PromptTemplate(
+        input_variables=["product"],
+        template=prompt_template,
+    )
+    chain = LLMChain(llm=llm, prompt=prompt)
+    output = chain.run(product=product)
+
+    return output

agenta-0.1.0/agenta/templates/simple_prompt/requirements.txt

@@ -0,0 +1,3 @@
+langchain
+openai
+python-dotenv

agenta-0.1.0/agenta/templates/simple_prompt/template.toml

@@ -0,0 +1 @@
+short_desc="Simple app that uses one prompt using langchain"

agenta-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[tool.poetry]
+name = "agenta"
+version = "0.1.0"
+description = ""
+authors = ["Mahmoud Mabrouk <mahmoudmabrouk.mail@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+docker = "^6.1.1"
+click = "^8.1.3"
+fastapi = "^0.95.1"
+toml = "^0.10.2"
+questionary = "^1.10.0"
+ipdb = "^0.13.13"
+python-dotenv = "^1.0.0"
+
+[tool.poetry.dev-dependencies]
+pytest = "^6.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+agenta = "agenta.cli:cli"