upload

.gitignore

@@ -0,0 +1,65 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*.h5
+*.out
+
+# Distribution / packaging
+.Python
+build/
+experiments/
+develop-eggs/
+dist/
+downloads/
+saved_imgs/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+temp_data/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Debug
+debug.py
+debugs/
+tensorboard_log/
+saved_models/
+configs_collection/
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+#saved_model
+*.pth
+
+*.pt
+
+*.log

Dockerfile

@@ -0,0 +1,28 @@
+#FROM ubuntu:22.04
+FROM python:3.11-bullseye
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+USER root
+
+RUN apt-get update && apt-get install -y \
+    curl \
+    nano \
+    poppler-utils \
+    software-properties-common \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV APP_ROOT=/home
+
+WORKDIR /home
+COPY . .
+
+RUN chown -R root:root ${APP_ROOT} && chmod -R 777 ${APP_ROOT}
+
+RUN pip install --upgrade pip setuptools \
+    && pip install --no-cache-dir -r requirements.txt \
+    && pip install streamlit==1.38.0
+
+EXPOSE 7860
+
+ENTRYPOINT /home/server/start_server.sh

requirements.txt

@@ -0,0 +1,26 @@
+pandas
+pypdf
+unstructured
+typing
+pydantic
+llama-index==0.10.28
+llama-index-llms-openai-like==0.1.3
+llama-index-embeddings-openai==0.1.7
+llama-index-readers-web==0.1.8
+openai==1.53.0
+httpx==0.27.2
+#streamlit==1.41.1
+#streamlit-navigation-bar==3.3.0
+streamlit-community-navigation-bar==4.0.9
+aiohttp
+docx2txt
+trafilatura==1.8.1
+motor
+loguru
+qdrant-client==1.12.2
+Pillow
+stamina
+pdf2image==1.17.0
+st-clickable-images==0.0.3
+
+#arize-phoenix==2.5.0

server/.streamlit/config.toml

@@ -0,0 +1,3 @@
+[theme]
+base="light"
+primaryColor="#E20074"

server/app/config.py

@@ -0,0 +1,29 @@
+import os
+from typing import Any, List, Tuple, Type
+
+class Settings:
+    #==============================================================================
+    GLOBAL_API_BASE="https://llm-server.llmhub.t-systems.net/queue"
+    GLOBAL_API_KEY=os.getenv("GLOBAL_AIFS_API_KEY")
+
+app_settings = Settings()
+
+from loguru import logger
+import sys
+from datetime import time, timezone
+import os, time
+
+os.environ['TZ'] = 'Europe/Berlin'
+time.tzset()
+
+
+def only_level(level):
+    def is_level(record):
+        return record['level'].name == level
+
+    return is_level
+
+#logger.remove(0)
+formato = '{time:YYYY-MM-DD HH:mm:ss.SS!UTC}   {level:8}  {message}  [{file} : {line}]'
+
+logger.add(sys.stderr, format=formato, level="DEBUG")

server/app/prompt_template.py

@@ -0,0 +1,6 @@
+VDR_PROMPT='''\
+You are an helpful AI assistant that answer the question base on the context provided.
+If the context doesn't help, truthfully answer with: I can't find that information in the given context.
+Base on the given context, focus to answer the following question:
+{user_question}
+'''

server/app/qdrant_db.py

@@ -0,0 +1,117 @@
+from qdrant_client import QdrantClient
+from qdrant_client.http import models
+from tqdm import tqdm
+import os
+import time
+import numpy as np
+from loguru import logger
+import stamina
+from typing import Any, List, Tuple, Type, Literal, Optional, Union, Dict
+
+class MyQdrantClient:
+    def __init__(self, path: str):
+        self.qdrant_client = QdrantClient(path=path)
+        logger.debug(f"Qdrant client created at {path}")
+
+    def create_collection(self, collection_name: str, vector_dim: int = 128, vector_type: str = "colbert"):
+        if vector_type == "colbert":
+            self.qdrant_client.create_collection(
+                collection_name=collection_name,
+                on_disk_payload=True,  # store the payload on disk
+                vectors_config=models.VectorParams(
+                    size=vector_dim,
+                    distance=models.Distance.COSINE,
+                    on_disk=True, # move original vectors to disk
+                    multivector_config=models.MultiVectorConfig(
+                        comparator=models.MultiVectorComparator.MAX_SIM
+                    ),
+                    #quantization_config=models.BinaryQuantization(
+                    #binary=models.BinaryQuantizationConfig(
+                    #    always_ram=True  # keep only quantized vectors in RAM
+                    #    ),
+                    #),
+                ),
+            )
+        elif vector_type == "dense":
+            self.qdrant_client.create_collection(
+                collection_name=collection_name,
+                on_disk_payload=True,  # store the payload on disk
+                vectors_config=models.VectorParams(
+                    size=vector_dim,
+                    distance=models.Distance.COSINE,
+                    on_disk=True, # move original vectors to disk
+                ),
+            )
+        else:
+            raise ValueError(f"Vector type {vector_type} not supported")
+
+        logger.debug(f"Qdrant collection of type {vector_type} : {collection_name} created")
+    
+    def delete_collection(self, collection_name: str):
+        self.qdrant_client.delete_collection(collection_name=collection_name)
+
+    @stamina.retry(on=Exception, attempts=3) # retry mechanism if an exception occurs during the operation
+    def upsert_to_qdrant(self, batch, collection_name: str):
+        try:
+            self.qdrant_client.upsert(
+                collection_name=collection_name,
+                points=batch,
+                wait=False,
+            )
+        except Exception as e:
+            logger.error(f"Error during upsert: {e}")
+            return False
+        return True
+
+    def upsert_multivector(self, index: int, multivector_input_list: list[Any], collection_name: str):
+        try:
+            points = []
+            for j, multivector in enumerate(multivector_input_list):
+                points.append(
+                    models.PointStruct(
+                        id=index + j,  # we just use the index as the ID
+                        vector=multivector,  # This is now a list of vectors
+                        payload={
+                            "source": "user uploaded data"
+                        },  # can also add other metadata/data
+                    )
+                )
+            # Upload points to Qdrant
+        
+            self.upsert_to_qdrant(points, collection_name)
+        except Exception as e:
+            logger.error(f"Vector DB client - error during upsert: {e}")
+    
+    def query_multivector(self, multivector_input, collection_name: str, top_k:int=10) -> list[int]:
+        try:
+            #logger.debug(f"Number of vector: {len(multivector_input)}")
+            #logger.debug(f"Vector dim: {len(multivector_input[0])}")
+
+            start_time = time.time()
+            search_result = self.qdrant_client.query_points(
+                collection_name=collection_name,
+                query=multivector_input,
+                limit=top_k,
+                # timeout=100,
+                # search_params=models.SearchParams(
+                #     quantization=models.QuantizationSearchParams(
+                #         ignore=False,
+                #         rescore=True,
+                #         oversampling=2.0,
+                #     )
+                # )
+            )
+            end_time = time.time()
+            elapsed_time = end_time - start_time
+            logger.debug(f"Search completed in {elapsed_time:.4f} seconds")
+
+            result = [x.id for x in search_result.points]
+            return result
+
+        except Exception as e:
+            logger.error(f"Error during query: {e}")
+            return None
+
+    def __del__(self):
+        self.qdrant_client.close()
+        

server/app/vdr_session.py

@@ -0,0 +1,298 @@
+import httpx
+import os
+import time
+import subprocess
+import uuid
+from loguru import logger
+from typing import Any, List, Tuple, Type, Literal, Optional, Union, Dict
+import httpx
+import os
+import time
+import subprocess
+import uuid
+import streamlit as st
+from openai import OpenAI
+import base64
+from tqdm import tqdm
+
+from app.config import app_settings
+
+from app.qdrant_db import MyQdrantClient
+
+from app.vdr_utils import (
+    get_text_embedding, 
+    get_image_embedding,
+    pdf_folder_to_images,
+    scale_image,
+    pil_image_to_base64,
+    load_images,
+)
+
+class VDRSession:
+    def __init__(self):
+        self.client = None
+        self.api_key = None
+        self.base_url = app_settings.GLOBAL_API_BASE
+        self.SAVE_DIR = None
+        self.db_collection = None
+        self.session_id = str(uuid.uuid4())[:5]
+        self.indexed_images = []
+        self.vector_db_client = None
+
+    def set_api_key(self, api_key: str):
+        if api_key is not None and len(api_key)>10:
+            try:
+                api_key = api_key.strip()
+                client = OpenAI(api_key=api_key,
+                                base_url=self.base_url)
+                models = client.models.list()
+                if models:
+                    self.api_key = api_key
+                    self.client = client
+                    return True
+            except Exception as e:
+                logger.debug(f'Incorrect API Key: {e}')
+
+        self.client = None
+        return False
+
+    def set_context(self, embed_model: str):
+        self.embed_model = embed_model
+
+        if not self.SAVE_DIR:
+            self.SAVE_DIR=os.path.join('./temp_data', self.session_id)
+            os.makedirs(self.SAVE_DIR, exist_ok=True)
+            self.SAVE_IMAGE_DIR=os.path.join(self.SAVE_DIR, 'images')
+            logger.debug(f'Created folder: {self.SAVE_DIR} and {self.SAVE_IMAGE_DIR}')
+
+        if not self.vector_db_client:
+            self.vector_db_client = MyQdrantClient(path=self.SAVE_DIR)
+
+        if not self.db_collection:
+            self.db_collection = f"qd-{embed_model}-{self.session_id}"
+            try:
+                if self.embed_model == "tsi-embedding-colqwen2-2b-v1":
+                    self.vector_db_client.create_collection(self.db_collection, vector_dim=128, vector_type="colbert")
+                elif self.embed_model == "jina-embedding-clip-v1":
+                    self.vector_db_client.create_collection(self.db_collection, vector_dim=768, vector_type="dense")
+                else:
+                    raise ValueError(f"Embedding model {self.embed_model} not supported")
+            except Exception as e:
+                logger.error(f"Error while creating collection: {e}")
+                
+        return True
+
+    def get_available_vlms(self) -> List[str]:
+        assert self.client != None
+        model_name_list = []
+        try:
+            models = self.client.models.list()
+            for model in models.data:
+                model_name = model.id
+                substrings = ['gemini','QWEN-VL2-7B']
+                if any(substring in model_name for substring in substrings):
+                    model_name_list.append(model.id)
+                
+        except Exception as e:
+            logger.error(f"Error while query all models: {e}")
+            raise e
+        
+        # Prioritize name
+        # Remove the item if it exists in the list
+        priority_item = "gemini-2.0-flash-exp-US"
+        if priority_item in model_name_list:
+            model_name_list.remove(priority_item)
+
+        # Insert the item at the beginning of the list
+        model_name_list.insert(0, priority_item)
+            
+        return model_name_list
+
+    def get_available_image_embeds(self) -> List[str]:
+        assert self.client != None
+        model_name_list = []
+        try:
+            models = self.client.models.list()
+            for model in models.data:
+                model_name = model.id
+                substrings = ['tsi-embedding','clip']
+                if any(substring in model_name for substring in substrings):
+                    model_name_list.append(model.id)
+
+        except Exception as e:
+            logger.error(f"Error while query all models: {e}")
+            raise e
+        
+        return model_name_list
+
+    def search_images(self, text: str, top_k: int = 5) -> list[str]:
+        assert self.client != None
+        assert self.vector_db_client != None
+        try:
+            if not self.indexed_images:
+                raise Exception("No indexed images found. You need to click on 'Add selected context' button to index images.")
+            text = text.strip()
+            if len(text) < 2:
+                return False
+
+            embeddings = get_text_embedding(
+                texts=text,
+                openai_client=self.client,
+                model=self.embed_model
+            )[0]
+
+            index_results = self.vector_db_client.query_multivector(
+                multivector_input=embeddings,
+                collection_name=self.db_collection,
+                top_k=top_k
+            )
+            image_list=[self.indexed_images[i] for i in index_results]
+            images = []
+            for img in image_list:
+                #with open(file, "rb") as image:
+                    #encoded = base64.b64encode(image.read()).decode()
+                encoded = pil_image_to_base64(img)
+                images.append(f"data:image/png;base64,{encoded}")
+            return images
+        except Exception as e:
+            logger.error(f"Error while generating image: {e}")
+            raise e
+
+    def ask(self, query: str, model: str, prompt_template: str, retrieved_context: Any, modality: str = "image", stream: bool = False) -> str:
+        assert self.client != None
+        assert query != None
+        assert prompt_template != None
+        assert retrieved_context != None
+
+        try:
+            prompt = prompt_template.format(user_question=query)
+            if modality == "image":
+                context = [
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": base64_image
+                        }
+                    } for base64_image in retrieved_context 
+                ]
+            
+            content = [
+                {
+                    "type": "text", 
+                    "text": prompt
+                }
+            ]
+            content=content+context
+            
+            messages=[
+                    {
+                        "role": "user",
+                        "content": content,
+                    }
+                ]
+
+            chat_response = self.client.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=0.1,
+                max_tokens=2048,
+                stream=stream,
+            )
+            if not stream:
+                return chat_response.choices[0].message.content
+            else:
+                for chunk in chat_response:
+                    if chunk.choices:
+                        if chunk.choices[0].delta.content is not None:
+                            yield chunk.choices[0].delta.content
+                            #print(chunk.choices[0].delta.content, end="", flush=True)
+
+        except Exception as e:
+            logger.error(f"Error while asking: {e}")
+            raise e
+
+    def indexing(self, uploaded_files: list[str], embed_model: str, indexing_bar: Optional[st.progress] = None) -> bool:
+        self.set_context(embed_model)
+
+        assert self.client != None
+        assert self.db_collection != None
+        assert self.SAVE_DIR != None
+        assert self.embed_model != None
+        assert len(uploaded_files) > 0
+
+        # Write files to disk
+        for file in uploaded_files :
+            path = os.path.join(self.SAVE_DIR, file.name)
+            if os.path.exists(path):
+                print("File existed, skip")
+                continue
+            with open(path, "wb") as f:
+                f.write(file.getvalue())
+        
+        image_path_list = pdf_folder_to_images(pdf_folder=self.SAVE_DIR, output_folder=self.SAVE_IMAGE_DIR)
+        logger.debug(f"Extracted {len(image_path_list)} images from {len(uploaded_files)} files.")
+
+        indexed_images = self.index_from_images(image_path_list, indexing_bar=indexing_bar)
+        logger.debug(f"Indexed {len(indexed_images)} images.")
+
+        self.indexed_images.extend(indexed_images)
+        return True
+
+    def clear_context(self):
+        self.indexed_images = []
+        self.vector_db_client.delete_collection(self.db_collection)
+        self.db_collection = None
+        self.vector_db_client = None
+
+        if self.SAVE_DIR:
+            if os.path.exists(self.SAVE_DIR):
+                subprocess.run(['rm', '-rf', self.SAVE_DIR])
+                logger.debug(f'Removed folder: {self.SAVE_DIR}')
+                self.SAVE_DIR = None
+        return True
+
+    def __del__(self):
+        self.clear_context()
+        logger.debug('VDR session is cleaned up.')
+
+    def index_from_images(self,
+        images_path_list: list, 
+        batch_size: int =5,
+        indexing_bar: Optional[st.progress] = None
+    ):
+        try:
+            indexed_images = []
+            total_len = len(images_path_list)
+            with tqdm(total=total_len, desc="Indexing Progress") as pbar:
+                for i in range(0, total_len, batch_size):
+                    try:
+                        batch = images_path_list[i:min(i+batch_size,total_len)]
+                        #batch = load_images(batch)
+                        batch = [scale_image(x, 768) for x in batch]
+
+                        embeddings = get_image_embedding(
+                            image_list=batch, 
+                            openai_client=self.client, 
+                            model=self.embed_model
+                        )
+                        self.vector_db_client.upsert_multivector(
+                            index=i,
+                            multivector_input_list=embeddings,
+                            collection_name=self.db_collection
+                        )
+
+                        indexed_images.extend(batch)
+                        # Update the progress bar
+                        pbar.update(batch_size)
+                        indexing_bar.progress(i/total_len, text=f"Indexing {i}/{total_len}")
+                    except Exception as e:
+                        logger.exception(f"Error during indexing: {e}")
+                        continue
+            
+            return indexed_images
+
+            logger.debug("Indexing complete!")
+        except Exception as e:
+            raise Exception(f"Error during indexing: {e}")
+
+    

server/app/vdr_utils.py

@@ -0,0 +1,179 @@
+from PIL import Image
+import numpy as np
+import base64
+import io
+from io import BytesIO
+from PIL import Image, ImageFile
+from pdf2image import convert_from_path
+import tempfile
+from multiprocessing import Pool
+import os
+from loguru import logger
+import uuid
+
+from typing import Any, List, Tuple, Type, Literal, Optional, Union, Dict
+
+def encode_image(image_path):
+  with open(image_path, "rb") as image_file:
+    return base64.b64encode(image_file.read()).decode('utf-8')
+
+def load_image_from_base64(image):
+    return Image.open(BytesIO(base64.b64decode(image)))
+
+def pil_image_to_base64(image: Image) -> str:
+    """
+    Convert a PIL Image object to its base64 representation.
+
+    Args:
+        image (Image): The PIL Image object to be converted.
+
+    Returns:
+        str: The base64 representation of the image.
+    """
+
+    # Create a bytes buffer
+    buffer = io.BytesIO()
+
+    # Save the image to the buffer
+    image.save(buffer, format="PNG")
+
+    # Get the bytes from the buffer
+    img_bytes = buffer.getvalue()
+
+    # Convert the bytes to base64
+    img_base64 = base64.b64encode(img_bytes).decode("utf-8")
+
+    return img_base64
+
+def scale_image(image: Image.Image, new_height: int = 1024) -> Image.Image:
+    """
+    Scale an image to a new height while maintaining the aspect ratio.
+    """
+    width, height = image.size
+    aspect_ratio = width / height
+    new_width = int(new_height * aspect_ratio)
+
+    scaled_image = image.resize((new_width, new_height))
+
+    return scaled_image
+
+def unflatten_array(flat_list, vector_size=128):
+    return np.array(flat_list).reshape(-1, vector_size)
+
+def get_image_embedding(image_list: list[Image], openai_client, model: str, flatten: bool = False) -> list:
+    """
+    Get the embedding of an image.
+
+    Args:
+        image (Image): The image to be embedded.
+
+    Returns:
+        list[list[float]] if flatten, 
+        else: list[list[list[float]]] with shape = (number of images (m), number of vector for each text (n), vector dim = 128)
+    """
+    if not isinstance(image_list, list):
+        image_list = [image_list]
+
+    input_base64_list = [f"data:image/png;base64,{pil_image_to_base64(image)}" for image in image_list]
+    # Get the embedding of the image
+    embedding = openai_client.embeddings.create(
+        input=input_base64_list,
+        model=model,
+        extra_body={
+            "modality": "image",
+            "encoding_format":"float" if not flatten else "base64",
+        },
+    )
+
+    result = []
+    for embed in embedding.data:
+        result.append(embed.embedding) # embed.embedding is a list[float] in case of flatten, else: list[list[float]]
+    return result
+
+def get_text_embedding(texts: list[str], openai_client, model: str, flatten: bool = False) -> list:
+    """
+    Get the embedding of a text.
+
+    Args:
+        text (str): The text to be embedded.
+
+    Returns:
+        list[list[float]] if flatten, 
+        else: list[list[list[float]]] with shape = (number of texts (m), number of vector for each text (n), vector dim = 128)
+    """
+    if not isinstance(texts, list):
+        texts = [texts]
+
+    # Get the embedding of the text
+    embedding = openai_client.embeddings.create(
+        input=texts,
+        model=model,
+        extra_body={
+            "encoding_format":"float" if not flatten else "base64",
+        },
+    )
+
+    result = []
+    for embed in embedding.data:
+        result.append(embed.embedding) # embed.embedding is a list[float] in case of flatten, else: list[list[float]]
+    return result
+
+def load_images(image_paths):
+    """
+    Load images from a list of paths and return a list of PIL image objects.
+
+    Args:
+        image_paths (list): List of image paths.
+
+    Returns:
+        list: List of PIL image objects.
+    """
+    images = []
+    for path in image_paths:
+        try:
+            img = Image.open(path)
+            images.append(img)
+        except Exception as e:
+            logger.error(f"Error loading image at path {path}: {str(e)}")
+    return images
+    
+
+def process_pdf(pdf_path: str, output_folder: str, thread_count=1):
+    result_image_paths = []
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        images = convert_from_path(pdf_path, dpi=200, output_folder=temp_dir, thread_count=thread_count)
+
+    # for page_num, image in enumerate(images):
+    #     image_filename = f"{str(uuid.uuid4())}.png"
+    #     image_path = os.path.join(output_folder, image_filename)
+    #     image.save(image_path, "PNG")
+    #     result_image_paths.append(image_path)
+    
+    # del images
+    # return result_image_paths
+    return images
+
+
+def pdf_folder_to_images(pdf_folder: str, output_folder: str, process_count: int = 2):
+    try:
+        if process_count is None:
+            process_count = os.cpu_count()
+
+        pdf_files = [os.path.join(pdf_folder, f) for f in os.listdir(pdf_folder)
+                     if f.lower().endswith('.pdf')]
+        
+        # Create a list of tuples containing (pdf_file, output_folder)
+        args = [(pdf_file, output_folder) for pdf_file in pdf_files]
+        
+        with Pool(process_count) as pool:
+            all_images = pool.starmap(process_pdf, args)
+        
+        result = [img for sublist in all_images for img in sublist]
+
+        logger.debug(f"Number of pdfs processed: {len(all_images)} - Number of images: {len(result)}")
+        return result
+    except Exception as e:
+        logger.exception(f"Error during processing pdf: {e}")
+
+

server/main.py

@@ -0,0 +1,49 @@
+import streamlit as st
+from streamlit_navigation_bar import st_navbar
+import st_pages as pg
+
+st.set_page_config(page_title='T-Systems LLM Playground', page_icon='favicon.png')
+
+with st.sidebar:
+    st.html("""<center><img src="https://upload.wikimedia.org/wikipedia/commons/0/0a/T-SYSTEMS-LOGO2013.svg" width="300" height="68" ></center>""")
+    
+    st.markdown('**This is playground for the LLM available via T-Systems AI Foundation Services**')
+
+pages_name = ['Visual Retrieval',"Documentation", "Terms & Conditions"]
+urls = {
+    #"Create API Key":"https://apikey.llmhub.t-systems.net/#/dashboard",
+    "Documentation":"https://docs.llmhub.t-systems.net/",
+    "Terms & Conditions":"https://smartchat.ai-health.aisf.t-systems.net/privacy"
+}
+styles = {
+    "nav": {
+        #"background-color": "#E20074",
+        "justify-content": "center",
+    },
+    "span": {
+        "border-radius": "0.5rem",
+        "color": "rgb(49, 51, 63)",
+        "margin": "0 0.125rem",
+        "padding": "0.4375rem 0.625rem",
+    },
+    # "active": {
+    #     "background-color": "rgba(256, 0, 116, 0.25)",
+    # },
+    "hover": {
+        "background-color": "rgba(226, 0, 116, 0.5)",
+    },
+}
+
+# options = {
+#     "show_menu": False,
+#     #"show_sidebar": False,
+# }
+page = st_navbar(
+    pages_name,
+    urls=urls,
+    styles=styles,
+    #options=options,
+)
+
+if page == 'Visual Retrieval':
+    pg.page_vdr()

server/st_pages/__init__.py

@@ -0,0 +1 @@
+from st_pages.page_vdr import page_vdr

server/st_pages/page_vdr.py

@@ -0,0 +1,120 @@
+import streamlit as st
+import os, time
+from app.vdr_session import *
+from app.vdr_schemas import *
+from st_clickable_images import clickable_images
+from app.prompt_template import VDR_PROMPT
+  
+def page_vdr():
+    st.header("Visual Document Retrieval")
+
+    # Store session context
+    if "vdr_session" not in st.session_state.keys():
+        st.session_state["vdr_session"] = VDRSession()
+
+    with st.sidebar:
+        
+        #api_key = st.text_input('Enter API Key:', type='password')
+        api_key = os.getenv("GLOBAL_AIFS_API_KEY")
+
+        check_api_key=st.session_state["vdr_session"].set_api_key(api_key)
+
+        if check_api_key:
+            st.success('API Key is valid!', icon='✅')
+            avai_llms = st.session_state["vdr_session"].get_available_vlms()
+            avai_embeds = st.session_state["vdr_session"].get_available_image_embeds()
+            selected_llm = st.sidebar.selectbox('Choose VLM models', avai_llms, key='selected_llm', disabled=not check_api_key)
+            selected_embed = st.sidebar.selectbox('Choose Embedding models', avai_embeds, key='selected_embed', disabled=not check_api_key)
+            #st.session_state["vdr_session"].set_context(selected_llm, selected_embed)
+        else:
+            st.warning('Please enter valid credentials!', icon='⚠️')
+
+    if check_api_key:
+        
+        with st.sidebar:
+            uploaded_files = st.file_uploader("Upload PDF files", key="uploaded_files", accept_multiple_files=True, disabled=not check_api_key)
+
+            if st.button("Add selected context", key="add_context", type="primary"):
+                if uploaded_files:
+                    try:
+                        indexing_bar = st.progress(0, text="Indexing...")
+                        if st.session_state["vdr_session"].indexing(uploaded_files, selected_embed, indexing_bar):
+                            st.success('Indexing completed!')
+                            indexing_bar.empty()
+                            #st.rerun()
+                        else:
+                            st.warning('Files empty or not supported.', icon='⚠️')
+                    except Exception as e:
+                        st.error(f"Error during indexing: {e}")
+                else:
+                    st.warning('Please upload files first!', icon='⚠️')
+
+            if st.button("🗑️ Remove all context", key="remove_context"):
+                try:
+                    st.session_state["vdr_session"].clear_context()
+                    st.success("Context removed")
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"Error during removing context: {e}")
+
+            
+            top_k_sim = st.slider(label="Top k similarity", min_value=1, max_value=10, value=3, step=1, key="top_k_sim")
+            #text_only_embed = st.toggle("Text only embedding", key="text_only_embed", value=False)
+            chat_prompt = st.text_area("Prompt template", key="chat_prompt", value=VDR_PROMPT, height=300)
+
+        query = st.text_input(label="Query",key='query',placeholder="Enter your query here",label_visibility="hidden", disabled=not st.session_state.get("vdr_session").indexed_images)
+
+        with st.expander(f"**Top {top_k_sim} retrieved contexts**", expanded=True):
+            try:
+                if len(query.strip()) > 2:
+                    if query != st.session_state.get("last_query", None):
+                        with st.spinner('Searching...'):
+                            st.session_state["last_query"] = query
+                            st.session_state["result_images"] = st.session_state["vdr_session"].search_images(query, top_k_sim)
+
+                if st.session_state.get("result_images", []):
+                    images = st.session_state["result_images"]
+
+                    clicked = clickable_images(
+                        images,
+                        titles=[f"Image #{str(i)}" for i in range(len(images))],
+                        div_style={"display": "flex", "justify-content": "center", "flex-wrap": "wrap"},
+                        img_style={"margin": "5px", "height": "200px"},
+                    )
+                    st.write(f"**Retrieved by: {selected_embed}**")
+
+                    @st.dialog(" ", width="large")
+                    def show_selected_image(id):
+                        st.markdown(f"**Similarity rank: {id}**")
+                        st.image(images[id])
+                    
+                    if clicked > -1 and clicked != st.session_state.get("clicked", None):
+                        show_selected_image(clicked)
+                        st.session_state["clicked"] = clicked
+                    
+            except Exception as e:
+                st.error(f"Error during search: {e}")
+
+        if st.session_state.get("result_images", None):
+            if st.button("Generate answer", key="ask", type="primary"):
+                if len(query.strip()) > 2:
+                    try:
+                        with st.spinner('Generating response...'):
+                            stream_response = st.session_state["vdr_session"].ask(
+                                query=query, 
+                                model=selected_llm, 
+                                prompt_template= chat_prompt, 
+                                retrieved_context=st.session_state["result_images"],
+                                stream=True
+                            )
+                            #print(stream_response)
+                            st.write_stream(stream_response)
+                            st.write(f"**Answered by: {selected_llm}**")
+                    except Exception as e:
+                        st.error(f"Error during asking: {e}")
+                else:
+                    st.warning('Please enter query first!', icon='⚠️')
+        
+        
+                
+            

server/start_server.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+#cd /home/server/ && python3 main.py
+cd /home/server/ && streamlit run main.py --server.port 7860