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

Conclusion - And what I learnt

Now you are free to prompt those different models!

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

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

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)