Chat with different models with Streamlit [Multichat]

A MultiChat with Streamlit

WIth this project, we will have a single Python Streamlit UI to Interact with:

• Streamlit OpenAI Chat
• Streamlit Anthropic Chat
• Streamlit Groq API
• Streamlit running local LLMs with Ollama

If you want, you can try these projects, first:

1. Install Python 🐍
2. Clone the repository
3. And install Python dependencies

• We will be using venv first and later create a Docker Container version with GH Ci/CD for SelfHosting the GenAI App.

See the related MultiChat repository and streamlit web app:

MultiChat UI

How the final multichat UI looks like

Multichat

Source Code for Streamlit Multichat

Lets have a look to the projects that have made this possible.

Streamlit Chat with OpenAI

Remember that there will be model/pricing changes over time: https://openai.com/api/pricing/

See how text will be tokenized: https://platform.openai.com/tokenizer

I first had a look to this existing project that used OpenAI API Key:

MultiChat UI

How the final multichat UI looks like

OpenAI Chatbot

Source Code fork on Github

• You will need an API key from OpenAI to use the project ❎

  • OpenAI API Keys

• Documentation for the models used can be found here:

  • OpenAI Models Documentation
  • GPT-4 Documentation
  • GPT-4o Documentation

git clone https://github.com/JAlcocerT/openai-chatbot

python -m venv openaichatbot #create it

openaichatbot\Scripts\activate #activate venv (windows)
source openaichatbot/bin/activate #(linux)

#deactivate #when you are done

Once active, you can just install the Python packages as usual and that will affect only that venv:

pip install -r requirements.txt #all at once

#pip list
#pip show streamlit #check the installed version

streamlit==1.26.0 #https://pypi.org/project/streamlit/#history
openai==0.28.0 #https://pypi.org/project/openai/#history

Now, to create the Docker Image:

apt-get update && sudo apt-get upgrade && curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
#sudo apt install docker-compose -y

apt install docker-compose -y

docker --version
docker-compose --version
#sudo systemctl status docker #and the status

Or with uv…

uv pip install ollama==0.2.1 --index-url https://pypi.org/simple

FROM python:3.11

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

# 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 /phidata/cookbook/llms/groq/video_summary/requirements.txt

#RUN sed -i 's/numpy==1\.26\.4/numpy==1.24.4/; s/pandas==2\.2\.2/pandas==2.0.2/' requirements.txt

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

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

Or if you prefer, with Podman:

podman build -t openaichatbot .
#podman run -d -p 8501:8501 openaichatbot

#docker run -p 8501:8501 openaichatbot:latest
docker exec -it openaichatbot /bin/bash

#sudo docker run -it -p 8502:8501 openaichatbot:latest /bin/bash

Run the Multichat App

With Portainer and the docker-compose stack:

version: '3'

services:
  streamlit-openaichatbot:
    image: openaichatbot
    container_name: openaichatbot
    volumes:
      - ai_openaichatbot:/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_openaichatbot:

Streamlit Chat with Groq

• https://github.com/tonykipkemboi/groq_streamlit_demo -> Groq + Streamlit Chat

Streamlit Chat with Anthropic

• https://github.com/TirendazAcademy/Streamlit-Tutorials/blob/main/Blog-Generator-App-with-Claude-API/app.py

Streamlit Chat with Ollama

• https://github.com/AIDevBytes/Streamlit-Ollama-Chatbot

You can setup Ollama locally like so:

Conclusions

It’s been great to put together all the mentioned projects in one streamlit UI.

Ive learnt a lot regarding the different API calls and local required setup (for ollama).

While enjoying the speed of querying models via Groq!

• https://console.anthropic.com/workbench/
• https://console.groq.com/keys
• https://platform.openai.com/api-keys

Now, here is the complete project, which you can selfhost with containers:

The Streamlit MultiChat Project

SelfHosting Streamlit MultiChat

podman build -t streamlit-multichat .

#version: '3'

services:
  streamlit-multichat:
    image: streamlit-multichat #ghcr.io/jalcocert/streamlit-multichat:latest
    container_name: streamlit_multichat
    volumes:
      - ai_streamlit_multichat:/app
    working_dir: /app
    #command: tail -f /dev/null # Keep the container running
    command: /bin/sh -c "\
      mkdir -p /app/.streamlit && \
      echo 'OPENAI_API_KEY = \"sk-proj-yourkey\"' > /app/.streamlit/secrets.toml && \
      echo 'GROQ_API_KEY = \"gsk_yourkey\"' >> /app/.streamlit/secrets.toml && \
      echo 'ANTHROPIC_API_KEY = \"sk-ant-api03-yourkey\"' >> /app/.streamlit/secrets.toml && \      
      streamlit run Z_multichat.py"
    ports:
      - "8503:8501"
    networks:
      - cloudflare_tunnel
      # - nginx_default      

volumes:
  ai_streamlit_multichat:

networks:
  cloudflare_tunnel:
    external: true
  # nginx_default:
  #   external: true

#docker-compose up -d

docker pull ghcr.io/jalcocert/streamlit-multichat:latest #:v1.1  #:latest

What Ive learnt

0. Now you are free to prompt those different models! via APIs:

• https://console.anthropic.com/workbench/
• https://console.groq.com/keys
• https://platform.openai.com/api-keys

1. Passing env variables via the secrets.toml is interesting approach.
2. Having sample streamlit auth functions handy
3. Using different pages to keep the code clean

Or you can do it with the built: streamlit-multichat

docker run -d \
  --name streamlit_multichat \
  -v ai_streamlit_multichat:/app \
  -w /app \
  -p 8501:8501 \
  ghcr.io/jalcocert/streamlit-multichat:latest \
  /bin/sh -c "mkdir -p /app/.streamlit && \
              echo 'OPENAI_API_KEY = \"sk-proj-openaiAPIhere\"' > /app/.streamlit/secrets.toml && \
              echo 'GROQ_API_KEY = \"gsk_groqAPIhere\"' >> /app/.streamlit/secrets.toml && \
              streamlit run Z_multichat.py"

During the process, I also explored: SliDev PPTs, ScrapeGraph, DaLLe, Streamlit Auth and OpenAI as Custom Agents.

It was also a good chance to use Github Actions CI/CD with buildx - to get MultiArch container image.

And ofc, the SliDev PPT is also using Github Actions with Pages and it is built with a different workflow. This one

Once you get to know how to use an API, is quite easy to add new ones.

And feel free to use any of these:

Remember to link the GHCR Package with your repository Readme:

name: CI/CD Build MultiArch

on:
  push:
    branches:
      - main

jobs:
  build-and-push:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout repository
      uses: actions/checkout@v2

    - name: Set up QEMU
      uses: docker/setup-qemu-action@v1

    - name: Set up Docker Buildx #here the cool thing happens
      uses: docker/setup-buildx-action@v1

    - name: Login to GitHub Container Registry
      uses: docker/login-action@v1
      with:
        registry: ghcr.io
        username: ${{ github.actor }}
        password: ${{ secrets.CICD_TOKEN_MultiChat }}

    - name: Build and push Docker image
      uses: docker/build-push-action@v2
      with:
        context: .
        push: true
        platforms: linux/amd64,linux/arm64 #any other
        tags: |
          ghcr.io/yourGHuser/multichat:v1.0
          ghcr.io/yourGHuser/multichat:latest          

#build and push the image and manifest to DockerHub
docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t yourDockerHubUser/multichat --push .

• Similar Tools - https://github.com/yvann-ba/Robby-chatbot
  • https://github.com/yvann-ba/Robby-chatbot?tab=MIT-1-ov-file#readme

Chat with CSV, PDF, TXT files 📄 and YTB videos 🎥 | using Langchain🦜 | OpenAI | Streamlit ⚡

git clone https://github.com/yvann-hub/Robby-chatbot.git
cd Robby-chatbot

python3 -m venv robby #create it

robby\Scripts\activate #activate venv (windows)
source robby/bin/activate #(linux)

streamlit run src/Home.py
#deactivate #when you are done

This one also summarizes YT Videos thanks to https://python.langchain.com/v0.2/docs/tutorials/summarization/

F/OSS RAGs

• Mem0 ( ex-embedchain ) - https://github.com/mem0ai/mem0
  • https://github.com/mem0ai/mem0/tree/main/embedchain/examples
  • https://docs.embedchain.ai/examples/full_stack
  • https://docs.mem0.ai/examples/personal-travel-assistant
  • With Qdrant vector DB - https://docs.mem0.ai/examples/customer-support-agent

version: '3'
services:
  qdrant:
    container_name: my_qdrant_container
    image: qdrant/qdrant
    ports:
      - "6333:6333"
    volumes:
      - qdrant_data:/path/to/qdrant_data

volumes:
  qdrant_data:

Build resource-driven LLM-powered bots

• LangChain
• LLamaIndex

LlamaIndex is a data framework for your LLM applications

• PandasAI
• Chainlit - https://docs.chainlit.io/integrations/llama-index

Chainlit is an open-source Python package to build production ready Conversational AI.

F/OSS Knowledge Graphs

• Neo4j - A popular graph database that uses a property graph model. It supports complex queries and provides a rich ecosystem of tools and integrations.
• Apache Jena - A Java framework for building semantic web and linked data applications. It provides tools for RDF data, SPARQL querying, and OWL reasoning.

How to use LLMs with MultiAgents Frameworks

• MetaGPT
• CrewAI - CrewAI is designed to enable AI agents to assume roles, share goals, and operate in a cohesive unit
• AutoGen
• ChatDev - https://github.com/OpenBMB/ChatDev

Try them together with LLMOps Tools like Pezzo AI or Agenta

F/OSS Conversational AI

• RASA - https://github.com/RasaHQ/conversational-ai-course-3.x
  • https://www.youtube.com/watch?v=hIWnpyTWsLQ

Build Conversational AI Experiences

• Chatwoot

# Download the env file template
wget -O .env https://raw.githubusercontent.com/chatwoot/chatwoot/develop/.env.example
# Download the Docker compose template
wget -O docker-compose.yaml https://raw.githubusercontent.com/chatwoot/chatwoot/develop/docker-compose.production.yaml

version: '3'

services:
  base: &base
    image: chatwoot/chatwoot:latest
    env_file: .env ## Change this file for customized env variables
    volumes:
      - /data/storage:/app/storage

  rails:
    <<: *base
    depends_on:
      - postgres
      - redis
    ports:
      - '127.0.0.1:3000:3000'
    environment:
      - NODE_ENV=production
      - RAILS_ENV=production
      - INSTALLATION_ENV=docker
    entrypoint: docker/entrypoints/rails.sh
    command: ['bundle', 'exec', 'rails', 's', '-p', '3000', '-b', '0.0.0.0']

  sidekiq:
    <<: *base
    depends_on:
      - postgres
      - redis
    environment:
      - NODE_ENV=production
      - RAILS_ENV=production
      - INSTALLATION_ENV=docker
    command: ['bundle', 'exec', 'sidekiq', '-C', 'config/sidekiq.yml']

  postgres:
    image: postgres:12
    restart: always
    ports:
      - '127.0.0.1:5432:5432'
    volumes:
      - /data/postgres:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=chatwoot
      - POSTGRES_USER=postgres
      # Please provide your own password.
      - POSTGRES_PASSWORD=

  redis:
    image: redis:alpine
    restart: always
    command: ["sh", "-c", "redis-server --requirepass \"$REDIS_PASSWORD\""]
    env_file: .env
    volumes:
      - /data/redis:/data
    ports:
      - '127.0.0.1:6379:6379'

• FlowiseAI

• Langflow - Visual framework for building multi-agent and RAG applications.

  • It is open-source, Python-powered, fully customizable, LLM and vector store agnostic.
  • https://docs.langflow.org/getting-started-installation
  • MIT Licensed ❤️- https://github.com/langflow-ai/langflow?tab=MIT-1-ov-file#readme

pip install langflow==1.0.0 #https://pypi.org/project/langflow/
python -m langflow run

Langflow is a no-code AI ecosystem, integrating seamlessly with the tools and stacks your team knows and loves.

FAQ

• Langchain + Docker + Neo4j + Ollama - https://github.com/docker/genai-stack

The GenAI Stack will get you started building your own GenAI application in no time

Similar Free and Open Tools for Generative AI

• Using PrivateGPT to Chat with your Docs Locally

• Agents Swarm with CrewAI and Docker

• Ollama with Docker

• Open Web UI - previously known as Ollama Web UI

• Fabric - a toolbox that contains various AI tools you can use for different tasks

  • https://github.com/danielmiessler/fabric

How can I use LLMs to help me code

Open Source VSCode extensions:

• https://github.com/codota/TabNine

  • MIT

• https://marketplace.visualstudio.com/items?itemName=TabNine.tabnine-vscode

• Tabby

• https://github.com/sourcegraph/cody - AI that knows your entire codebase

  • https://sourcegraph.com/docs/cody
  • https://marketplace.visualstudio.com/items?itemName=sourcegraph.cody-ai

• https://sourcegraph.com/docs/cody/usage-and-pricing

• Codeium

  • https://marketplace.visualstudio.com/items?itemName=Codeium.CodeiumVS
  • https://github.com/Exafunction/codeium-chrome

• Rivet - https://github.com/Ironclad/rivet/releases

• Codestral Mamba (Open Source Coding Model from MistralAI)