Version 1.0.2

.github/workflows/upload-pypi-dev.yml

@@ -8,10 +8,10 @@ on:
         type: choice
         description: "Choose the library to deploy (note: it points to develop branch only)"
         options: 
-          - llmstudio
-          - llmstudio-core
-          - llmstudio-proxy
-          - llmstudio-tracker
+          - ./libs/llmstudio
+          - ./libs/core
+          - ./libs/proxy
+          - ./libs/tracker
       target_version:
         description: "Target version (e.g., 1.1.0)"
         required: true
@@ -20,14 +20,6 @@ on:
 jobs:
   deploy:
     runs-on: ubuntu-latest
-    env:
-      MODULE_PATH: |
-        ${{ 
-          inputs.library == 'llmstudio' && './libs/llmstudio' ||
-          inputs.library == 'llmstudio-core' && './libs/core' ||
-          inputs.library == 'llmstudio-proxy' && './libs/proxy' ||
-          inputs.library == 'llmstudio-tracker' && './libs/tracker'
-        }}
     steps:
       - name: Checkout code
         uses: actions/checkout@v3
@@ -47,49 +39,38 @@ jobs:
         run: poetry config pypi-token.pypi ${{ secrets.PYPI_API_TOKEN }}
 
       - name: Check PyPI for Target Version
-        working-directory: ${{ env.MODULE_PATH }}
+        working-directory: ${{ inputs.library }}
         id: check-version
         run: |
           TARGET_VERSION="${{ github.event.inputs.target_version }}"
-          PACKAGE_NAME=${{ inputs.library }}
+          PACKAGE_NAME=$(poetry version | awk '{print $1}')
           RESPONSE=$(curl -s "https://pypi.org/pypi/$PACKAGE_NAME/json" || echo "{}")
           echo "$RESPONSE" | jq -r '.releases | keys[]' > all_versions.txt
-          if grep -qx "$TARGET_VERSION" all_versions.txt; then
-            echo "exists=true" >> $GITHUB_ENV
-          else
-            echo "exists=false" >> $GITHUB_ENV
-          fi
 
-      # Step 4: Decide on the next alpha version
-      - name: Determine Next Alpha Version
-        id: determine-version
-        run: |
-          if [[ "${{ env.exists }}" == "true" ]]; then
+          if grep -qx "$TARGET_VERSION" all_versions.txt; then
             echo "Error: Version ${{ github.event.inputs.target_version }} already exists on PyPI."
             exit 1
           fi
-          BASE_VERSION="${{ github.event.inputs.target_version }}"
-          PACKAGE_NAME=${{ inputs.library }}
-          ALPHA_VERSIONS=$(grep -E "^$BASE_VERSIONa[0-9]+$" all_versions.txt | sort -V || true)
-          if [[ -z "$ALPHA_VERSIONS" ]]; then
-            NEW_VERSION="${BASE_VERSION}a0"
+
+          NEXT_ALPHA=$(grep "^${TARGET_VERSION}a[0-9]*$" all_versions.txt | sort -V | tail -n 1 | awk -F'a' '{print $2}')
+
+          if [[ -z "$NEXT_ALPHA" ]]; then
+            NEW_VERSION="${TARGET_VERSION}a0"
           else
-            LATEST_ALPHA=$(echo "$ALPHA_VERSIONS" | tail -n 1)
-            NEXT_ALPHA_NUM=$(( $(echo "$LATEST_ALPHA" | grep -oE '[0-9]+$') + 1 ))
-            NEW_VERSION="${BASE_VERSION}a${NEXT_ALPHA_NUM}"
+            NEW_VERSION="${TARGET_VERSION}a$((NEXT_ALPHA + 1))"
           fi
           echo "new_version=$NEW_VERSION" >> $GITHUB_ENV
           echo "Determined new version: $NEW_VERSION"
 
       - name: Build and publish to PyPI as development release
-        working-directory: ${{ env.MODULE_PATH }}
+        working-directory: ${{ inputs.library }}
         run: |
           poetry version ${{ env.new_version }}
           poetry build
           poetry publish
 
       - name: Commit and push updated pyproject.toml
-        working-directory: ${{ env.MODULE_PATH }}
+        working-directory: ${{ inputs.library }}
         run: |
           git config user.name "GitHub Actions"
           git config user.email "actions@github.com"
@@ -98,43 +79,21 @@ jobs:
           git push
 
       - name: Wait for PyPI to update
-        working-directory: ${{ env.MODULE_PATH }}
+        working-directory: ${{ inputs.library }}
         run: |
           VERSION=$(poetry version --short)
-          echo "Checking for ${{ github.event.inputs.library }}==$VERSION on PyPI..."
+          PACKAGE_NAME=$(poetry version | awk '{print $1}')
+          echo "Checking for $PACKAGE_NAME==$VERSION on PyPI..."
           for i in {1..10}; do
-            if python -m pip install ${{ github.event.inputs.library }}==${VERSION} --dry-run >/dev/null 2>&1; then
-              echo "Package ${{ github.event.inputs.library }}==${VERSION} is available on PyPI."
+            if python -m pip install $PACKAGE_NAME==${VERSION} --dry-run >/dev/null 2>&1; then
+              echo "Package $PACKAGE_NAME==${VERSION} is available on PyPI."
               break
             else
-              echo "Package ${{ github.event.inputs.library }}==${VERSION} not available yet. Waiting 15 seconds..."
+              echo "Package $PACKAGE_NAME==${VERSION} not available yet. Waiting 15 seconds..."
               sleep 15
             fi
             if [ $i -eq 10 ]; then
               echo "Package did not become available in time."
               exit 1
             fi
           done
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Extract version for tagging Docker image
-        working-directory: ${{ env.MODULE_PATH }}
-        id: get_version
-        run: echo "VERSION=$(poetry version --short)" >> $GITHUB_ENV
-
-      - name: Build Docker images
-        working-directory: ./deploy
-        run: |
-          make version=${{ env.VERSION }} build-${{ github.event.inputs.library }}
-
-      - name: Push Docker images
-        run: |
-          docker push tensoropsai/${{ github.event.inputs.library }}:${{ env.VERSION }}

docs/how-to/deploy-on-gcp/deploy-on-google-cloud-platform.mdx

@@ -0,0 +1,160 @@
+Learn how to deploy LLMstudio as a containerized application on Google Kubernetes Engine and make calls from a local repository.
+
+
+## Prerequisites
+To follow this guide you need to have the following set-up:
+
+- A **project** on google cloud platform.
+- **Kubernetes Engine** API enabled on your project.
+- **Kubernetes Engine Admin** role for the user performing the guide.
+
+## Deploy LLMstudio
+
+This example demonstrates a public deployment. For a private service accessible only within your enterprise infrastructure, deploy it within your own Virtual Private Cloud (VPC).
+<Steps>
+  <Step title="Navigate to Kubernetes Engine">
+    Begin by navigating to the Kubernetes Engine page.
+  </Step>
+  <Step title="Select Deploy">
+    Go to **Workloads** and **Create a new Deployment**.
+    <Frame>
+      <img src="how-to/deploy-on-gcp/step-2.png" />
+    </Frame>
+  </Step>
+  <Step title="Name Your Deployment">
+    Rename your project. We will call the one in this guide **llmstudio-on-gcp**.
+    <Frame>
+      <img src="how-to/deploy-on-gcp/step-3.png" />
+    </Frame>
+  </Step>
+  <Step title="Select Your Cluster">
+    Choose between **creating a new cluster** or **using an existing cluster**. 
+    For this guide, we will create a new cluster and use the default region.
+    <Frame>
+      <img src="how-to/deploy-on-gcp/step-4.png" />
+    </Frame>
+  </Step>
+  <Step title="Proceed to Container Details">
+    Once done done with the **Deployment configuration**, proceed to **Container details**.
+  </Step>
+  <Step title="Set Image Path">
+    In the new container section, select **Existing container image**.
+
+
+    Copy the path to LLMstudio's image available on Docker Hub.
+    ```bash Image Path
+    tensoropsai/llmstudio:latest
+    ```
+    Set it as the **Image path** to your container.
+    <Frame>
+      <img src="how-to/deploy-on-gcp/step-6.png" />
+    </Frame>
+  </Step>
+  <Step title="Set Environment Variables">
+    Configure the following mandatory environment variables:
+| Environment Variable       | Value     |
+|----------------------------|-----------|
+| `LLMSTUDIO_ENGINE_HOST`    | 0.0.0.0   |
+| `LLMSTUDIO_ENGINE_PORT`    | YOUR_DESIRED_PORT     |
+| `LLMSTUDIO_TRACKING_HOST`  | 0.0.0.0   |
+| `LLMSTUDIO_TRACKING_PORT`  | YOUR_DESIRED_PORT     |
+
+Additionally, set the `GOOGLE_API_KEY` environment variable to enable calls to Google's Gemini models.
+<Tip>Refer to **SDK/LLM/Providers** for instructions on setting up other providers.</Tip>
+
+<Frame>
+  <img src="how-to/deploy-on-gcp/step-7.png" />
+</Frame>
+
+  </Step>
+  <Step title="Proceed to Expose (Optional)">
+    After configuring your container, proceed to **Expose (Optional)**.
+  </Step>
+  <Step title="Expose Ports">
+    Select **Expose deployment as a new service** and leave the first item as is.
+
+    <Frame>
+      <img src="how-to/deploy-on-gcp/step-9-1.png" />
+    </Frame>
+
+    Add two other items, and expose the ports defined in the **Set Environment Variables** step.
+
+    <Frame>
+      <img src="how-to/deploy-on-gcp/step-9-2.png" />
+    </Frame>
+  </Step>
+  <Step title="Deploy">
+    After setting up and exposing the ports, press **Deploy**.
+  <Check>You have successfully deployed **LLMstudio on Google Cloud Platform**!</Check>
+  </Step>
+
+</Steps>
+
+## Make a Call
+Now let's make a call to our LLMstudio instance on GCP!
+
+
+
+<Steps>
+  <Step title="Set Up Project">
+    Setup a simple project with this two files:
+    1. `simple-call.ipynb`
+    2. `.env`
+  </Step>
+
+  <Step title="Set Up Files">
+    <Tabs>
+      <Tab title=".env">
+
+        Go to your newly deployed **Workload**, scroll to the **Exposing services** section, and take note of the Host of your endpoint.
+        <Frame>
+          <img src="how-to/deploy-on-gcp/step-env.png" />
+        </Frame>
+
+        Create your `.env` file with the following:
+
+        ```env .env
+        LLMSTUDIO_ENGINE_HOST = "YOUR_HOST"
+        LLMSTUDIO_ENGINE_PORT = "YOUR_ENGINE_PORT"
+        LLMSTUDIO_TRACKING_HOST = "YOUR_TRACKING_PORT"
+        LLMSTUDIO_TRACKING_PORT = "YOUR_HOST"
+        ```
+
+        <Check>You are done seting up you **.env** file!</Check>
+
+
+
+
+      </Tab>
+      <Tab title="simple-call.ipynb">
+        Start by importing llmstudio:
+        ```python 1st cell
+        from llmstudio import LLM
+        ```
+
+        Set up your LLM. We will be using `gemini-1.5-flash` for this guide.
+        ```python 2nd cell
+        llm = LLM('vertexai/gemini-1.5-flash')
+        ```
+
+        Chat with your model.
+        ```python 3rd cell
+        llm.chat('Hello!')
+        print(response.chat_output)
+        ```
+
+        <Frame>
+          <img src="how-to/deploy-on-gcp/step-llmstudio-call.png" />
+        </Frame>
+
+
+        <Check>You are done calling llmstudio on GCP!</Check>
+
+      </Tab>
+
+    </Tabs>
+  </Step>
+
+
+</Steps>
+

docs/mint.json

@@ -87,3 +87,4 @@
     "baseUrl": "http://localhost:8000"
   }
 }
+

docs/sdk/llm/chat.mdx

@@ -0,0 +1,86 @@
+Make chat calls using your LLM.
+
+## Parameters
+The llm.chat method can have the following parameters.
+| Parameter      | Type   | Description                                                                 |
+|-------------------|--------|-----------------------------------------------------------------------------|
+| `input `       | str    | The input message to send to the chat model.                                   |
+| `is_stream`    | bool  | The temperature parameter for the model.                                       |
+| `**kwargs`          | dict  | Additional parameters to pass to the chat model.                           |
+
+<Check>Refer to your provider-specific documentation for additional kwargs you can use.</Check>
+
+## Returns
+| Output            | Type   | Description                                                                 |
+|-------------------|--------|-----------------------------------------------------------------------------|
+| `ChatCompletion`  | object | A chat completion object in the OpenAI format + metrics computed by LLMstudio.|
+
+
+## Usage
+Here's how to use `.chat()` to make calls to your LLM.
+
+<Steps>
+    <Step>
+        Start by importing LLM.
+        ```python
+        from llmstudio import LLM
+        ```
+    </Step>
+    <Step >
+        Set up an LLM from your desired provider.
+        ```python
+        llm = LLM('openai/gpt-4o')
+        ```
+    </Step>
+    <Step>
+        Create your message. Your message can be a simple `string` or a message in the `OpenAI format`.
+
+       <Tabs>
+            <Tab title="String format">
+                ```python
+                message = "Hello, how are you today?"
+                ```
+            </Tab>
+            <Tab title="OpenAI format">
+                ```python
+                message = [
+                {"role": "system", "content": "You are a helpfull assistant."},
+                {"role": "user", "content": "Hello, how are you today?"}
+                ]
+                ```
+            </Tab>
+        </Tabs> 
+
+    </Step>
+    <Step>
+
+        <Tabs>
+            <Tab title="Non-stream response">
+                Get your response.
+                ```python
+                response = llm.chat(message)
+                ```
+
+                Vizualize your response.
+                 ```python
+                print(response)
+                ```
+            </Tab>
+            <Tab title="Stream response">
+                Get your response.
+                ```python
+                response = llm.chat(message, is_stream = True)
+                ```
+
+                Vizualize your response.
+                 ```python
+                for chunk in response:
+                    print(chunk)
+                ```
+            </Tab>
+        </Tabs> 
+
+        <Check>You are done chating with your **LLMstudio LLM**!</Check>
+    </Step>
+</Steps>
+