Pezzo AI is a developer-first, open-source platform designed to streamline the development and deployment of applications that leverage large language models (LLMs).

  • Key Features of Pezzo AI

    • Focus on Developer Experience:
      • Centralized Prompt Management 🎛️: Offers a central location to manage all prompts, simplifying organization and version control. Explore more.
      • Streamlined Prompt Design & Versioning 📝: Facilitates easy creation, editing, testing, and versioning of prompts, enhancing the iterative process. Discover how.
      • Instant Deployments ⚡: Supports rapid deployment of LLM functionalities, enabling faster experimentation and shortened development cycles. Learn about deployments.

  • Why to keep reading?

    • You will discover how to use Pezzo AI
    • It will NOT cost money, neither cloud registrations ✅

The Pezzo AI Project

Pezzo AI aims to streamline prompt design, version management, instant delivery, collaboration, troubleshooting, observability and more.

Open-source, developer-first LLMOps platform

Why Pezzo AI

Pezzo is an open-source AI development toolkit that provides a centralized platform for managing AI prompts, experiments, and models.

It aims to streamline the AI development process by making it easier for developers to collaborate, optimize costs, and troubleshoot issues.

  • Core Benefits
    • Increased Developer Productivity 🚀: Streamlined workflows and centralized tools boost efficiency, focusing on innovation.
    • Improved Collaboration 🤝: Provides a shared space for managing prompts and functionalities, enhancing teamwork.
    • Reduced Development Costs 💸: Efficient resource management and faster deployments contribute to cost savings.
With Pezzo AI you can... 👇

Pezzo is a valuable resource for developers and teams working with AI models. It can be used to:

  • Prompt Management: Simplify creation, editing, and version control of AI prompts.
  • Experimentation: Conduct A/B tests and target specific experiments to enhance conversion rates.
  • Cost Optimization: Achieve up to 50% savings in AI operations through optimized resource management.
  • Real-Time Trading: Utilize advanced features for real-time trading and access comprehensive charts.
  • Comprehensive Troubleshooting: Leverage execution history, time-travel debugging, and robust test suites for confident deployment.

SelfHosting Pezzo AI

First Things First - Get Docker! 🐋

Important step and quite recommended for any SelfHosting Project - Get Docker Installed

It will be one command, this one, if you are in Linux:

apt-get update && sudo apt-get upgrade && curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh && docker version

Pezzo AI with Docker

In order to run Pezzo AI using Docker Compose, use the following commands:

git clone https://github.com/pezzolabs/pezzo.git
cd pezzo
docker-compose up

These commands will clone the Pezzo repository from GitHub, navigate into the Pezzo directory, and then start the Pezzo stack.

It will download and execute the Docker images from Github Container Repository:

  • ghcr.io/pezzolabs/pezzo/server:latest
  • ghcr.io/pezzolabs/pezzo/console:latest
  • ghcr.io/pezzolabs/pezzo/proxy:latest

If you are curious…

...this is how the PezzoAI Docker Compose looks like 👇 
include:
  - ./docker-compose.infra.yaml

services:
  pezzo-server:
    image: ghcr.io/pezzolabs/pezzo/server:latest
    build:
      context: .
      dockerfile: ./apps/server/Dockerfile
    restart: always
    env_file:
      - ./.env
      - ./.env.local
      - ./apps/server/.env
      - ./apps/server/.env.local
    environment:
      - DATABASE_URL=postgres://postgres:postgres@postgres:5432/pezzo
      - SUPERTOKENS_CONNECTION_URI=http://supertokens:3567
      - CLICKHOUSE_HOST=clickhouse
      - REDIS_URL=redis://redis-stack-server:6379
      - KMS_LOCAL_ENDPOINT=http://local-kms:9981
    ports:
      - "3000:3000"
    depends_on:
      pezzo-prisma-migrate:
        condition: service_completed_successfully
      pezzo-clickhouse-migrate:
        condition: service_completed_successfully
      postgres:
        condition: service_healthy
      supertokens:
        condition: service_healthy
      clickhouse:
        condition: service_healthy
      redis-stack-server:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "curl 'http://pezzo-server:3000/api/healthz'"]
      interval: 10s
      timeout: 5s
      retries: 5

  pezzo-console:
    image: ghcr.io/pezzolabs/pezzo/console:latest
    build:
      context: .
      dockerfile: ./apps/console/Dockerfile
    restart: always
    env_file:
      - ./.env
      - ./apps/console/.env
    ports:
      - "4200:8080"
    depends_on:
      pezzo-server:
        condition: service_healthy

  pezzo-proxy:
    image: ghcr.io/pezzolabs/pezzo/proxy:latest
    build:
      context: .
      dockerfile: ./apps/proxy/Dockerfile
    restart: always
    env_file:
      - ./.env
      - ./apps/proxy/.env
    ports:
      - "3001:3000"
    depends_on:
      pezzo-server:
        condition: service_healthy

Now you can use Pezzo AI at: localhost:3000

The services and components that run with this stack include PostgreSQL, Redis and the Pezzo components (Server, Console).

It will also automatically apply database migration to the PostgreSQL database.

After the stack has started, you can access the PezzoAI Console at http://localhost:4200.

FAQ

How to use Pezzo AI with Python

pip install pezzo

from pezzo.client import pezzo

Is Pezzo AI API Up?

import requests

url = "https://api.pezzo.ai/api/healthz"

response = requests.request("GET", url)

print(response.text)
How to iterate with Python and AI Apps with Docker-Compose ⏬ 
FROM python:3.10-slim

# Install git
RUN apt-get update && apt-get install -y git nano

# Set up the working directory
WORKDIR /app

# Clone the repository
#RUN git clone https://github.com/JAlcocerT/openai-chatbot

#WORKDIR /openai-chatbot

# Install Python requirements
#RUN pip install -r requirements.txt

# Set the entrypoint to a bash shell
CMD ["/bin/bash"]

export DOCKER_BUILDKIT=1
docker build --no-cache -t pythonaicontainer . #> build_log.txt 2>&1

Or if you prefer, with Podman:

podman build -t pythonaicontainer .
#podman run -d -p 8501:8501 pythonaicontainer
docker run -d --name python_container_for_dev -p 8502:8501 pythonaicontainer tail -f /dev/null

And go to its interactive terminal with:

docker exec -it python_container_for_dev /bin/bash
#podman exec -it python_container_for_dev /bin/bash

With Portainer:

version: '3'

services:
  dev-pythonaicontainer:
    image: pythonaicontainer
    container_name: pythonaicontainer
    volumes:
      - ai_pythonaicontainer:/app
    working_dir: /app  # Set the working directory to /app
    #command: /bin/sh -c "streamlit run streamlit_app.py"    
    command: tail -f /dev/null #streamlit run appv2.py # tail -f /dev/null
    ports:
      - "8507:8501"    

volumes:
  ai_pythonaicontainer: