From 4ed30d597b476fe02e697fe45180f9bb17c49369 Mon Sep 17 00:00:00 2001
From: Yassine Souissi <74144843+yassinsws@users.noreply.github.com>
Date: Wed, 11 Sep 2024 14:56:58 +0200
Subject: [PATCH 1/3] Make readme file more beginner friendly  (#153)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Kaan Çaylı <38523756+kaancayli@users.noreply.github.com>
---
 README.MD | 102 ++++++++++++++++++++++--------------------------------
 1 file changed, 42 insertions(+), 60 deletions(-)

diff --git a/README.MD b/README.MD
index 7ad4f29..01d8d71 100644
--- a/README.MD
+++ b/README.MD
@@ -10,7 +10,8 @@ Currently, Pyris empowers [Iris](https://artemis.cit.tum.de/about-iris), a virtu
 
 ## Setup
 ### With local environment
-> **⚠️ Warning:** For local Weaviate vector database setup, please refer to [Weaviate Docs](https://weaviate.io/developers/weaviate/quickstart).
+> **⚠️ Warning:** To change the local Weaviate vector database setup, please refer to [Weaviate Docs](https://weaviate.io/developers/weaviate/quickstart).
+
  - Check python version: `python --version` (should be 3.12)
  - Install packages: `pip install -r requirements.txt`
  - Create an `application.local.yml` file in the root directory. This file includes configurations that can be used by the application.
@@ -60,85 +61,66 @@ Currently, Pyris empowers [Iris](https://artemis.cit.tum.de/about-iris), a virtu
     ```
  - Access API docs: http://localhost:8000/docs
 
-### With docker
-Pyris can be deployed using Docker, which provides an easy way to set up the application in a consistent environment.
-Below are the instructions for setting up Pyris using Docker.
-
-#### Prerequisites
-- Ensure Docker and Docker Compose are installed on your machine.
-- Clone the Pyris repository to your local machine.
-- 
-#### Setup Instructions
-
-1. **Build and Run the Containers**
+### Getting Started with Docker
 
-   You can run Pyris in different environments: development or production. Docker Compose is used to orchestrate the different services, including Pyris, Weaviate, and Nginx.
+Deploying Pyris using Docker is a straightforward way to set up the application in a consistent environment. Here's how you can do it:
 
-   - **For Development:**
+**Build and Run the Containers**
 
-     Use the following command to start the development environment:
-
-     ```bash
-     docker-compose -f docker-compose/pyris-dev.yml up --build
-     ```
+The essential part of setting up Pyris with Docker is building and running the containers. Docker Compose is used to manage the different services, including Pyris, Weaviate, and Nginx, for both development and production environments.
 
-     This command will:
-     - Build the Pyris application from the Dockerfile.
-     - Start the Pyris application along with Weaviate in development mode.
-     - Mount the local configuration files (`application.local.yml` and `llm-config.local.yml`) for easy modification.
+- **For Development:**
 
-     The application will be available at `http://localhost:8000`.
+   To start the development environment, run:
 
-   - **For Production:**
-
-     Use the following command to start the production environment:
-
-     ```bash
-     docker-compose -f docker-compose/pyris-production.yml up -d
-     ```
+   ```bash
+   docker-compose -f docker-compose/pyris-dev.yml up --build
+   ```
 
-     This command will:
-     - Pull the latest Pyris image from the GitHub Container Registry.
-     - Start the Pyris application along with Weaviate and Nginx in production mode.
-     - Nginx will serve as a reverse proxy, handling SSL termination if certificates are provided.
+   This command will:
+   - Build the Pyris application.
+   - Start the Pyris application along with Weaviate in development mode.
+   - Mount local configuration files for easy modification.
 
-     The application will be available at `https://<your-domain>`.
+   The application will be available at `http://localhost:8000`.
 
-2. **Configuration**
+- **For Production:**
 
-   - **Weaviate**: Weaviate is configured via the `weaviate.yml` file. By default, it runs on port 8001.
-   - **Pyris Application**: The Pyris application configuration is handled through environment variables and mounted YAML configuration files.
-   - **Nginx**: Nginx is used for handling requests in a production environment and is configured via `nginx.yml`.
+   To start the production environment, run:
 
-3. **Accessing the Application**
+   ```bash
+   docker-compose -f docker-compose/pyris-production.yml up -d
+   ```
 
-   - For development, access the API documentation at: `http://localhost:8000/docs`
-   - For production, access the application at your domain (e.g., `https://<your-domain>`).
+   This command will:
+   - Pull the latest Pyris image from the GitHub Container Registry.
+   - Start Pyris along with Weaviate and Nginx in production mode.
+   - Nginx will handle SSL and serve as a reverse proxy.
 
-4. **Stopping the Containers**
+   The application will be available at `https://<your-domain>`.
 
-   To stop the running containers, use:
+#### Additional Steps (Optional)
 
-   ```bash
-   docker-compose -f docker-compose/pyris-dev.yml down
-   ```
+If you need to stop the containers, use:
 
-   or
+```bash
+docker-compose -f docker-compose/pyris-dev.yml down
+```
 
-   ```bash
-   docker-compose -f docker-compose/pyris-production.yml down
-   ```
+or
 
-5. **Logs and Debugging**
+```bash
+docker-compose -f docker-compose/pyris-production.yml down
+```
 
-   - View the logs for a specific service, e.g., Pyris:
+You can also customize the configuration for Weaviate, Pyris, and Nginx by editing their respective configuration files. However, the default setup should work fine for most users.
 
-     ```bash
-     docker-compose -f docker-compose/pyris-dev.yml logs pyris-app
-     ```
+For development, access the API documentation at `http://localhost:8000/docs`. For production, access the application at your domain (e.g., `https://<your-domain>`).
 
-   - For production, ensure that Nginx and Weaviate services are running smoothly and check their respective logs if needed.
+If you need to view logs or debug, you can check the logs of specific services using:
 
----
+```bash
+docker-compose -f docker-compose/pyris-dev.yml logs pyris-app
+```
 
-This setup should help you run the Pyris application in both development and production environments with Docker. Ensure you modify the configuration files as per your specific requirements before deploying.
\ No newline at end of file
+This setup should help you run the Pyris application in both development and production environments with Docker. Ensure you modify the configuration files as per your specific requirements before deploying.

From cdf1d8887c2dea469cc17acb087bc9187f46dfaf Mon Sep 17 00:00:00 2001
From: Maximilian Anzinger
 <44003963+MaximilianAnzinger@users.noreply.github.com>
Date: Tue, 17 Sep 2024 11:14:03 +0200
Subject: [PATCH 2/3] Add requirements list to competency extraction pipeline
 (#158)

---
 app/pipeline/competency_extraction_pipeline.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/app/pipeline/competency_extraction_pipeline.py b/app/pipeline/competency_extraction_pipeline.py
index da224ff..a2288ab 100644
--- a/app/pipeline/competency_extraction_pipeline.py
+++ b/app/pipeline/competency_extraction_pipeline.py
@@ -31,7 +31,12 @@ def __init__(self, callback: Optional[CompetencyExtractionCallback] = None):
             implementation_id="competency_extraction_pipeline_reference_impl"
         )
         self.callback = callback
-        self.request_handler = CapabilityRequestHandler(requirements=RequirementList())
+        self.request_handler = CapabilityRequestHandler(
+            requirements=RequirementList(
+                gpt_version_equivalent=4.5,
+                context_length=16385,
+            )
+        )
         self.output_parser = PydanticOutputParser(pydantic_object=Competency)
 
     def __call__(

From 79414c75ec70cf1758ac98964315b702457890e0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kaan=20=C3=87ayl=C4=B1?=
 <38523756+kaancayli@users.noreply.github.com>
Date: Sat, 21 Sep 2024 15:35:53 +0200
Subject: [PATCH 3/3] `Docker`: Production setup without Nginx (#159)

---
 README.MD                            | 382 +++++++++++++++++++++------
 application.example.yml              |   7 +
 application.test.yml                 |   5 -
 docker/pyris-production-internal.yml |  36 +++
 llm_config.example.yml               | 124 +++++++++
 5 files changed, 467 insertions(+), 87 deletions(-)
 create mode 100644 application.example.yml
 delete mode 100644 application.test.yml
 create mode 100644 docker/pyris-production-internal.yml
 create mode 100644 llm_config.example.yml

diff --git a/README.MD b/README.MD
index 01d8d71..2773c33 100644
--- a/README.MD
+++ b/README.MD
@@ -1,126 +1,344 @@
 # Pyris V2
-Pyris is an intermediary system that links the [Artemis](https://github.com/ls1intum/Artemis) platform with various Large Language Models (LLMs). It provides a REST API that allows Artemis to interact with different pipelines based on specific tasks.
+
+Pyris is an intermediary system that connects the [Artemis](https://github.com/ls1intum/Artemis) platform with various Large Language Models (LLMs). It provides a REST API that allows Artemis to interact with different pipelines based on specific tasks.
+
+Currently, Pyris powers [Iris](https://artemis.cit.tum.de/about-iris), a virtual AI tutor that assists students with their programming exercises on Artemis in a pedagogically meaningful way.
+
+## Table of Contents
+- [Features](#features)
+- [Setup](#setup)
+  - [Prerequisites](#prerequisites)
+  - [Local Development Setup](#local-development-setup)
+  - [Docker Setup](#docker-setup)
+    - [Development Environment](#development-environment)
+    - [Production Environment](#production-environment)
+- [Customizing Configuration](#customizing-configuration)
+- [Troubleshooting](#troubleshooting)
+- [Additional Notes](#additional-notes)
 
 ## Features
-- **Modular Design**: Pyris is built to be modular, allowing for integration of new models and pipelines. This design helps the system adapt to different requirements.
-- **RAG Support**: Pyris implements Retrieval-Augmented Generation (RAG) using [Weaviate](https://weaviate.io/), a vector database. This feature enables the generation of responses based on retrieved context, potentially improving the relevance of outputs.
-- **Flexible Pipelines**: The system supports various pipelines that can be selected depending on the task at hand, providing versatility in handling different types of requests.
 
-Currently, Pyris empowers [Iris](https://artemis.cit.tum.de/about-iris), a virtual AI Tutor that helps students with their programming exercises on Artemis in a didactically meaningful way.
+- **Exercise Support**: Empowers Iris to provide feedback on programming exercises, enhancing the learning experience for students. Iris analyzes submitted code, feedback, and build logs generated by Artemis to provide detailed insights.
+
+- **Course Content Support**: Leverages RAG (Retrieval-Augmented Generation) to enable Iris to provide detailed explanations for course content, making it easier for students to understand complex topics based on instructor-provided learning materials.
+
+- **Competency Generation**: Automates the generation of competencies for courses, reducing manual effort in creating Artemis competencies.
 
 ## Setup
-### With local environment
-> **⚠️ Warning:** To change the local Weaviate vector database setup, please refer to [Weaviate Docs](https://weaviate.io/developers/weaviate/quickstart).
 
- - Check python version: `python --version` (should be 3.12)
- - Install packages: `pip install -r requirements.txt`
- - Create an `application.local.yml` file in the root directory. This file includes configurations that can be used by the application.
-    - Example `application.local.yml`:
+### Prerequisites
+
+- **Python 3.12**: Ensure that Python 3.12 is installed.
+
+  ```bash
+  python --version
+  ```
+
+- **Docker and Docker Compose**: Required for containerized deployment.
+
+---
+
+### Local Development Setup
+
+> **Note:** If you need to modify the local Weaviate vector database setup, please refer to the [Weaviate Documentation](https://weaviate.io/developers/weaviate/quickstart).
+
+#### Steps
+
+1. **Clone the Pyris Repository**
+
+   Clone the Pyris repository into a directory on your machine:
+
+   ```bash
+   git clone https://github.com/ls1intum/Pyris.git Pyris
+   ```
+
+2. **Install Dependencies**
+
+   Navigate to the Pyris directory and install the required Python packages:
+
+   ```bash
+   cd Pyris
+   pip install -r requirements.txt
+   ```
+
+3. **Create Configuration Files**
+
+   - **Create an Application Configuration File**
+
+     Create an `application.local.yml` file in the root directory. You can use the provided `application.example.yml` as a base.
+
+     ```bash
+     cp application.example.yml application.local.yml
+     ```
+
+     **Example `application.local.yml`:**
+
      ```yaml
-    api_keys:
-      - token: "secret"
+     api_keys:
+       - token: "your-secret-token"
+
+     weaviate:
+       host: "localhost"
+       port: "8001"
+       grpc_port: "50051"
+
+     env_vars:
+     ```
+
+   - **Create an LLM Config File**
 
-    weaviate:
-      host: "localhost"
-      port: "8001"
-      grpc_port: "50051"
+     Create an `llm-config.local.yml` file in the root directory. You can use the provided `llm-config.example.yml` as a base.
 
-    env_vars:
-      test: "test"
+     ```bash
+     cp llm-config.example.yml llm-config.local.yml
      ```
- - Create an `llm-config.local.yml` file in the root directory. This file includes a list of models with their configurations that can be used by the application.
-   - Example `llm-config.local.yml`:
+
+     **Example OpenAI Configuration:**
+
+     ```yaml
+     - id: "oai-gpt-35-turbo"
+       name: "GPT 3.5 Turbo"
+       description: "GPT 3.5 16k"
+       type: "openai_chat"
+       model: "gpt-3.5-turbo"
+       api_key: "<your_openai_api_key>"
+       tools: []
+       capabilities:
+         input_cost: 0.5
+         output_cost: 1.5
+         gpt_version_equivalent: 3.5
+         context_length: 16385
+         vendor: "OpenAI"
+         privacy_compliance: false
+         self_hosted: false
+         image_recognition: false
+         json_mode: true
+     ```
+
+     **Example Azure OpenAI Configuration:**
+
      ```yaml
-      - id: "<model-id>"
-        name: "<custom-model-name>"
-        description: "<model-description>"
-        type: "<model-type>, e.g. azure-chat, ollama"
-        endpoint: "<your-endpoint>"
-        api_version: "<your-api-version>"
-        azure_deployment: "<your-azure-deployment-name>"
-        model: "<model>, e.g. gpt-3.5-turbo"
-        api_key: "<your-api-key>"
-        tools: []
-        capabilities:
-          input_cost: 0.5
-          output_cost: 1.5
-          gpt_version_equivalent: 3.5
-          context_length: 16385
-          vendor: "<your-vendor>"
-          privacy_compliance: True
-          self_hosted: False
-          image_recognition: False
-          json_mode: True
+     - id: "azure-gpt-4-omni"
+       name: "GPT 4 Omni"
+       description: "GPT 4 Omni on Azure"
+       type: "azure_chat"
+       endpoint: "<your_azure_model_endpoint>"
+       api_version: "2024-02-15-preview"
+       azure_deployment: "gpt4o"
+       model: "gpt4o"
+       api_key: "<your_azure_api_key>"
+       tools: []
+       capabilities:
+         input_cost: 6
+         output_cost: 16
+         gpt_version_equivalent: 4.5  # Equivalent GPT version of the model
+         context_length: 128000
+         vendor: "OpenAI"
+         privacy_compliance: true
+         self_hosted: false
+         image_recognition: true
+         json_mode: true
      ```
- - Each model configuration in the `llm-config.local.yml` file also include capabilities that will be used by the application to select the best model for a specific task.
 
-#### Run server
- - Run server: 
-   ```[bash]
-     APPLICATION_YML_PATH=<path-to-your-application-yml-file> LLM_CONFIG_PATH=<path-to-your-llm-config-yml> uvicorn app.main:app --reload
-    ```
- - Access API docs: http://localhost:8000/docs
+     **Explanation of Configuration Parameters**
+
+     The configuration parameters are used by Pyris's capability system to select the appropriate model for a task.
+
+     **Parameter Descriptions:**
+
+     - `api_key`: The API key for the model.
+     - `capabilities`: The capabilities of the model.
+
+       - `context_length`: The maximum number of tokens the model can process in a single request.
+       - `gpt_version_equivalent`: The equivalent GPT version of the model in terms of overall capabilities.
+       - `image_recognition`: Whether the model supports image recognition (for multimodal models).
+       - `input_cost`: The cost of input tokens for the model.
+       - `output_cost`: The cost of output tokens for the model.
+       - `json_mode`: Whether the model supports structured JSON output mode.
+       - `privacy_compliance`: Whether the model complies with privacy regulations.
+       - `self_hosted`: Whether the model is self-hosted.
+       - `vendor`: The provider of the model (e.g., OpenAI).
+       - `speed`: The model's processing speed.
+
+     - `description`: Additional information about the model.
+     - `id`: Unique identifier for the model across all models.
+     - `model`: The official name of the model as used by the vendor.
+     - `name`: A custom, human-readable name for the model.
+     - `type`: The model type, used to select the appropriate client (e.g., `openai_chat`, `azure_chat`, `ollama`).
+     - `endpoint`: The URL to connect to the model.
+     - `api_version`: The API version to use with the model.
+     - `azure_deployment`: The deployment name of the model on Azure.
+     - `tools`: The tools supported by the model.
 
-### Getting Started with Docker
+     > **Notes on `gpt_version_equivalent`:** The `gpt_version_equivalent` field is subjective and used to compare capabilities of different models using GPT models as a reference. For example:
+     >- GPT-4 Omni equivalent: 4.5
+     >- GPT-4 Omni Mini equivalent: 4.25
+     >- GPT-4 equivalent: 4
+     >- GPT-3.5 Turbo equivalent: 3.5
 
-Deploying Pyris using Docker is a straightforward way to set up the application in a consistent environment. Here's how you can do it:
+     > **Warning:** Most existing pipelines in Pyris require a model with a `gpt_version_equivalent` of **4.5 or higher**. It is advised to define models in the `llm-config.local.yml` file with a `gpt_version_equivalent` of 4.5 or higher.
 
-**Build and Run the Containers**
+4. **Run the Server**
 
-The essential part of setting up Pyris with Docker is building and running the containers. Docker Compose is used to manage the different services, including Pyris, Weaviate, and Nginx, for both development and production environments.
+   Start the Pyris server:
 
-- **For Development:**
+   ```bash
+   APPLICATION_YML_PATH=./application.local.yml \
+   LLM_CONFIG_PATH=./llm-config.local.yml \
+   uvicorn app.main:app --reload
+   ```
+
+5. **Access API Documentation**
+
+   Open your browser and navigate to [http://localhost:8000/docs](http://localhost:8000/docs) to access the interactive API documentation.
+
+---
+
+### Docker Setup
+
+Deploying Pyris using Docker ensures a consistent environment and simplifies the deployment process.
+
+#### Prerequisites
+
+- **Docker**: Install Docker from the [official website](https://www.docker.com/get-started).
+- **Docker Compose**: Comes bundled with Docker Desktop or install separately on Linux.
+- **Clone the Pyris Repository**: If not already done, clone the repository.
+- **Create Configuration Files**: Create the `application.local.yml` and `llm-config.local.yml` files as described in the [Local Development Setup](#local-development-setup) section.
+
+  ```bash
+  git clone https://github.com/ls1intum/Pyris.git Pyris
+  cd Pyris
+  ```
+
+#### Docker Compose Files
 
-   To start the development environment, run:
+- **Development**: `docker-compose/pyris-dev.yml`
+- **Production with Nginx**: `docker-compose/pyris-production.yml`
+- **Production without Nginx**: `docker-compose/pyris-production-internal.yml`
+
+#### Running the Containers
+
+##### **Development Environment**
+
+1. **Start the Containers**
 
    ```bash
    docker-compose -f docker-compose/pyris-dev.yml up --build
    ```
 
-   This command will:
-   - Build the Pyris application.
-   - Start the Pyris application along with Weaviate in development mode.
-   - Mount local configuration files for easy modification.
+   - Builds the Pyris application.
+   - Starts Pyris and Weaviate in development mode.
+   - Mounts local configuration files for easy modification.
+
+2. **Access the Application**
+
+   - Application URL: [http://localhost:8000](http://localhost:8000)
+   - API Docs: [http://localhost:8000/docs](http://localhost:8000/docs)
+
+##### **Production Environment**
 
-   The application will be available at `http://localhost:8000`.
+###### **Option 1: With Nginx**
 
-- **For Production:**
+1. **Prepare SSL Certificates**
 
-   To start the production environment, run:
+   - Place your SSL certificate (`fullchain.pem`) and private key (`priv_key.pem`) in the specified paths or update the paths in the Docker Compose file.
+
+2. **Start the Containers**
 
    ```bash
    docker-compose -f docker-compose/pyris-production.yml up -d
    ```
 
-   This command will:
-   - Pull the latest Pyris image from the GitHub Container Registry.
-   - Start Pyris along with Weaviate and Nginx in production mode.
-   - Nginx will handle SSL and serve as a reverse proxy.
+   - Pulls the latest Pyris image.
+   - Starts Pyris, Weaviate, and Nginx.
+   - Nginx handles SSL termination and reverse proxying.
+
+3. **Access the Application**
+
+   - Application URL: `https://your-domain.com`
+
+###### **Option 2: Without Nginx**
+
+1. **Start the Containers**
+
+   ```bash
+   docker-compose -f docker-compose/pyris-production-internal.yml up -d
+   ```
+
+   - Pulls the latest Pyris image.
+   - Starts Pyris and Weaviate.
+
+2. **Access the Application**
+
+   - Application URL: [http://localhost:8000](http://localhost:8000)
+
+---
+
+#### Managing the Containers
+
+- **Stop the Containers**
+
+  ```bash
+  docker-compose -f <compose-file> down
+  ```
+
+  Replace `<compose-file>` with the appropriate Docker Compose file.
+
+- **View Logs**
+
+  ```bash
+  docker-compose -f <compose-file> logs -f <service-name>
+  ```
+
+  Example:
+
+  ```bash
+  docker-compose -f docker-compose/pyris-dev.yml logs -f pyris-app
+  ```
+
+- **Rebuild Containers**
+
+  If you've made changes to the code or configurations:
+
+  ```bash
+  docker-compose -f <compose-file> up --build
+  ```
+
+#### Customizing Configuration
+
+- **Environment Variables**
+
+  You can customize settings using environment variables:
+
+  - `PYRIS_DOCKER_TAG`: Specifies the Pyris Docker image tag.
+  - `PYRIS_APPLICATION_YML_FILE`: Path to your `application.yml` file.
+  - `PYRIS_LLM_CONFIG_YML_FILE`: Path to your `llm-config.yml` file.
+  - `PYRIS_PORT`: Host port for Pyris application (default is `8000`).
+  - `WEAVIATE_PORT`: Host port for Weaviate REST API (default is `8001`).
+  - `WEAVIATE_GRPC_PORT`: Host port for Weaviate gRPC interface (default is `50051`).
 
-   The application will be available at `https://<your-domain>`.
+- **Configuration Files**
 
-#### Additional Steps (Optional)
+  Modify configuration files as needed:
 
-If you need to stop the containers, use:
+  - **Pyris Configuration**: Update `application.yml` and `llm-config.yml`.
+  - **Weaviate Configuration**: Adjust settings in `weaviate.yml`.
+  - **Nginx Configuration**: Modify Nginx settings in `nginx.yml` and related config files.
 
-```bash
-docker-compose -f docker-compose/pyris-dev.yml down
-```
+## Troubleshooting
 
-or
+- **Port Conflicts**
 
-```bash
-docker-compose -f docker-compose/pyris-production.yml down
-```
+  If you encounter port conflicts, change the host ports using environment variables:
 
-You can also customize the configuration for Weaviate, Pyris, and Nginx by editing their respective configuration files. However, the default setup should work fine for most users.
+  ```bash
+  export PYRIS_PORT=8080
+  ```
 
-For development, access the API documentation at `http://localhost:8000/docs`. For production, access the application at your domain (e.g., `https://<your-domain>`).
+- **Permission Issues**
 
-If you need to view logs or debug, you can check the logs of specific services using:
+  Ensure you have the necessary permissions for files and directories, especially for SSL certificates.
 
-```bash
-docker-compose -f docker-compose/pyris-dev.yml logs pyris-app
-```
+- **Docker Resources**
 
-This setup should help you run the Pyris application in both development and production environments with Docker. Ensure you modify the configuration files as per your specific requirements before deploying.
+  If services fail to start, ensure Docker has sufficient resources allocated.
\ No newline at end of file
diff --git a/application.example.yml b/application.example.yml
new file mode 100644
index 0000000..9e1490b
--- /dev/null
+++ b/application.example.yml
@@ -0,0 +1,7 @@
+api_keys:
+  - token: "secret"
+
+weaviate:
+  host: "localhost"
+  port: "8001"
+  grpc_port: "50051"
\ No newline at end of file
diff --git a/application.test.yml b/application.test.yml
deleted file mode 100644
index fdcd1f4..0000000
--- a/application.test.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-api_keys:
-  - token: "secret"
-
-env_vars:
-    test: "test"
\ No newline at end of file
diff --git a/docker/pyris-production-internal.yml b/docker/pyris-production-internal.yml
new file mode 100644
index 0000000..bd4aa04
--- /dev/null
+++ b/docker/pyris-production-internal.yml
@@ -0,0 +1,36 @@
+# ----------------------------------------------------------------------------------------------------------------------
+# Setup for a Pyris server suitable for internal network requests (without nginx).
+# ----------------------------------------------------------------------------------------------------------------------
+# It is designed to take in environment variables for configuration, similar to the production setup.
+# ----------------------------------------------------------------------------------------------------------------------
+
+services:
+  pyris-app:
+    extends:
+      file: ./pyris.yml
+      service: pyris-app
+    image: ghcr.io/ls1intum/pyris:${PYRIS_DOCKER_TAG:-latest}
+    pull_policy: always
+    restart: unless-stopped
+    volumes:
+      - ${PYRIS_APPLICATION_YML_FILE}:/config/application.yml:ro
+      - ${PYRIS_LLM_CONFIG_YML_FILE}:/config/llm_config.yml:ro
+    ports:
+      - "${PYRIS_PORT:-8000}:8000"
+    networks:
+      - pyris
+
+  weaviate:
+    extends:
+      file: ./weaviate.yml
+      service: weaviate
+    ports:
+      - "${WEAVIATE_PORT:-8001}:8001"
+      - "${WEAVIATE_GRPC_PORT:-50051}:50051"
+    networks:
+      - pyris
+
+networks:
+  pyris:
+    driver: "bridge"
+    name: pyris
\ No newline at end of file
diff --git a/llm_config.example.yml b/llm_config.example.yml
new file mode 100644
index 0000000..c7c6671
--- /dev/null
+++ b/llm_config.example.yml
@@ -0,0 +1,124 @@
+- api_key:
+  api_version: 2024-05-01-preview
+  azure_deployment: gpt-35-turbo
+  capabilities:
+    context_length: 16385
+    gpt_version_equivalent: 3.5
+    image_recognition: false
+    input_cost: 0.5
+    json_mode: true
+    output_cost: 1.5
+    privacy_compliance: true
+    self_hosted: false
+    vendor: OpenAI
+  description: GPT 3.5 16k on Azure
+  endpoint: '<your-endpoint>'
+  id: azure-gpt-35-turbo
+  model: gpt-3.5-turbo
+  name: GPT 3.5 Turbo
+  type: azure_chat
+- api_key:
+  capabilities:
+    input_cost: 0.5
+    output_cost: 1.5
+    gpt_version_equivalent: 3.5
+    context_length: 16385
+    vendor: "OpenAI"
+    privacy_compliance: false
+    self_hosted: false
+    image_recognition: false
+    son_mode: true
+  description: GPT 3.5 16k
+  id: oai-gpt-35-turbo
+  model: gpt-3.5-turbo
+  name: GPT 3.5 Turbo
+  type: openai_chat
+- api_key:
+  api_version: 2024-02-15-preview
+  azure_deployment: gpt-4-turbo
+  capabilities:
+    context_length: 128000
+    gpt_version_equivalent: 4
+    image_recognition: false
+    input_cost: 10
+    json_mode: true
+    output_cost: 30
+    privacy_compliance: true
+    self_hosted: false
+    vendor: OpenAI
+  description: GPT 4 Turbo 128k on Azure
+  endpoint: '<your-endpoint>'
+  id: azure-gpt-4-turbo
+  model: gpt-4-turbo
+  name: GPT 4 Turbo
+  type: azure_chat
+- api_key:
+  api_version: 2024-02-15-preview
+  azure_deployment: gpt-4o
+  capabilities:
+    context_length: 128000
+    gpt_version_equivalent: 4.5
+    image_recognition: true
+    input_cost: 5
+    json_mode: true
+    output_cost: 15
+    privacy_compliance: true
+    self_hosted: false
+    vendor: OpenAI
+  description: GPT 4 Omni on Azure
+  endpoint: '<your-endpoint>'
+  id: azure-gpt-4-omni
+  model: gpt-4o
+  name: GPT 4 Omni
+  type: azure_chat
+- api_key:
+  api_version: 2023-03-15-preview
+  azure_deployment: gpt-4o-mini
+  capabilities:
+    context_length: 128000
+    gpt_version_equivalent: 4.25
+    image_recognition: true
+    input_cost: 0.15
+    json_mode: true
+    output_cost: 0.075
+    privacy_compliance: true
+    self_hosted: false
+    vendor: OpenAI
+  description: GPT 4 Omni Mini on Azure
+  endpoint: '<your-endpoint>'
+  id: azure-gpt-4-omni-mini
+  model: gpt-4o-mini
+  name: GPT 4 Omni Mini
+  type: azure_chat
+- api_key:
+  api_version: '2023-05-15T00:00:00.000Z'
+  azure_deployment: te-3-large
+  capabilities:
+    context_length: 8191
+    input_cost: 0.13
+    output_cost: 0.065
+    privacy_compliance: true
+    self_hosted: false
+    vendor: OpenAI
+  description: Embedding Large 8k Azure
+  endpoint: '<your-endpoint>'
+  id: embedding-large
+  model: text-embedding-3-large
+  name: Embedding Large
+  type: azure_embedding
+- api_key:
+  api_version: 2024-02-15-preview
+  azure_deployment: te-3-small
+  capabilities:
+    context_length: 8191
+    input_cost: 0.02
+    output_cost: 0
+    privacy_compliance: true
+    self_hosted: false
+    vendor: OpenAI
+  description: Embedding Small 8k Azure
+  endpoint: '<your-endpoint>'
+  id: embedding-small
+  model: text-embedding-3-small
+  name: Embedding Small
+  type: azure_embedding
\ No newline at end of file