add files

model_params.cfg

@@ -0,0 +1,20 @@
+[generator]
+PROVIDER = huggingface
+MODEL = meta-llama/Meta-Llama-3-8B-Instruct
+MAX_TOKENS = 768
+TEMPERATURE = 0.2
+INFERENCE_PROVIDER = novita
+ORGANIZATION = GIZ
+
+[reader]
+TYPE = INF_PROVIDERS
+INF_PROVIDER_MODEL = meta-llama/Llama-3.1-8B-Instruct
+DEDICATED_MODEL = meta-llama/Llama-3.1-8B-Instruct
+DEDICATED_ENDPOINT = https://qu2d8m6dmsollhly.us-east-1.aws.endpoints.huggingface.cloud
+NVIDIA_MODEL = meta-llama/Llama-3.1-8B-Instruct
+NVIDIA_ENDPOINT = https://huggingface.co/api/integrations/dgx/v1
+MAX_TOKENS = 768
+INF_PROVIDER = nebius
+
+[app]
+dropdown_default = Annual Consolidated OAG 2024

style.css

@@ -0,0 +1,362 @@
+
+/* :root {
+    --user-image: url('https://ih1.redbubble.net/image.4776899543.6215/st,small,507x507-pad,600x600,f8f8f8.jpg');
+  } */
+
+.warning-box {
+    background-color: #fff3cd;
+    border: 1px solid #ffeeba;
+    border-radius: 4px;
+    padding: 15px 20px;
+    font-size: 14px;
+    color: #856404;
+    display: inline-block;
+    margin-bottom: 15px;
+  }
+
+
+.tip-box {
+    background-color: #f0f9ff;
+    border: 1px solid #80d4fa;
+    border-radius: 4px;
+    margin-top:20px;
+    padding: 15px 20px;
+    font-size: 14px;
+    display: inline-block;
+    margin-bottom: 15px;
+    width: auto;
+    color:black !important;
+}
+
+body.dark .warning-box * {
+    color:black !important;
+}
+
+
+body.dark .tip-box * {
+    color:black !important;
+}
+
+
+.tip-box-title {
+    font-weight: bold;
+    font-size: 14px;
+    margin-bottom: 5px;
+}
+
+.light-bulb {
+    display: inline;
+    margin-right: 5px;
+}
+
+.gr-box {border-color: #d6c37c}
+
+#hidden-message{
+    display:none;
+}
+
+.message{
+    font-size:14px !important;
+}
+
+
+a {
+    text-decoration: none;
+    color: inherit;
+}
+
+.card {
+    background-color: white;
+    border-radius: 10px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    margin:20px;
+}
+
+.card-content {
+    padding: 20px;
+}
+
+.card-content h2 {
+    font-size: 14px !important;
+    font-weight: bold;
+    margin-bottom: 10px;
+    margin-top:0px !important;
+    color:#dc2626!important;;
+}
+
+.card-content p {
+    font-size: 12px;
+    margin-bottom: 0;
+}
+
+.card-footer {
+    background-color: #f4f4f4;
+    font-size: 10px;
+    padding: 10px;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.card-footer span {
+    flex-grow: 1;
+    text-align: left;
+    color: #999 !important;
+}
+
+.pdf-link {
+    display: inline-flex;
+    align-items: center;
+    margin-left: auto;
+    text-decoration: none!important;
+    font-size: 14px;
+}
+
+
+
+.message.user{
+    /* background-color:#7494b0 !important; */
+    border:none;
+    /* color:white!important; */
+}
+
+.message.bot{
+    /* background-color:#f2f2f7 !important; */
+    border:none;
+}
+
+/* .gallery-item > div:hover{
+    background-color:#7494b0 !important;
+    color:white!important;
+}
+.gallery-item:hover{
+    border:#7494b0 !important;
+}
+.gallery-item > div{
+    background-color:white !important;
+    color:#577b9b!important;
+}
+.label{
+    color:#577b9b!important;
+} */
+
+/* .paginate{
+    color:#577b9b!important;
+} */
+
+
+
+/* span[data-testid="block-info"]{
+    background:none !important;
+    color:#577b9b;
+  } */
+
+/* Pseudo-element for the circularly cropped picture */
+/* .message.bot::before {
+    content: '';
+    position: absolute;
+    top: -10px;
+    left: -10px;
+    width: 30px;
+    height: 30px;
+    background-image: var(--user-image);
+    background-size: cover;
+    background-position: center;
+    border-radius: 50%;
+    z-index: 10;
+  }
+   */
+
+label.selected{
+  background:none !important;
+}
+
+#submit-button{
+    padding:0px !important;
+}
+
+
+@media screen and (min-width: 1024px) {
+    div#tab-examples{
+        height:calc(100vh - 190px) !important;
+        overflow-y: auto;
+    }
+
+    div#sources-textbox{
+        height:calc(100vh - 190px) !important;
+        overflow-y: auto !important;
+    }
+
+    div#tab-config{
+        height:calc(100vh - 190px) !important;
+        overflow-y: auto !important;
+    }
+
+    div#chatbot-row{
+        height:calc(100vh - 90px) !important;
+    }
+
+    div#chatbot{
+        height:calc(100vh - 170px) !important;
+    }
+
+    .max-height{
+        height:calc(100vh - 90px) !important;
+        overflow-y: auto;
+    }
+
+    /* .tabitem:nth-child(n+3) {
+        padding-top:30px;
+        padding-left:40px;
+        padding-right:40px;
+    } */
+}
+
+footer {
+    visibility: hidden;
+    display:none !important;
+}
+
+
+@media screen and (max-width: 767px) {
+    /* Your mobile-specific styles go here */
+
+    div#chatbot{
+        height:500px !important;
+    }
+
+    #submit-button{
+        padding:0px !important;
+        min-width: 80px;
+    }
+
+    /* This will hide all list items */
+    div.tab-nav button {
+        display: none !important;
+    }
+
+    /* This will show only the first list item */
+    div.tab-nav button:first-child {
+        display: block !important;
+    }
+    
+    /* This will show only the first list item */
+    div.tab-nav button:nth-child(2) {
+        display: block !important;
+    }
+    
+    #right-panel button{
+        display: block !important;
+    }
+
+    /* ... add other mobile-specific styles ... */
+}
+
+
+body.dark .card{
+    background-color: #374151;
+}
+
+body.dark .card-content h2{
+    color:#f4dbd3 !important;
+}
+
+body.dark .card-footer {
+    background-color: #404652;
+}
+
+body.dark .card-footer span {
+    color:white !important;
+}
+
+
+.doc-ref{
+    color:#dc2626!important;
+    margin-right:1px;
+}
+
+.tabitem{
+    border:none !important;
+}    
+
+.other-tabs > div{
+    padding-left:40px;
+    padding-right:40px;
+    padding-top:10px;
+}
+
+.gallery-item > div{
+    white-space: normal !important; /* Allow the text to wrap */
+    word-break: break-word !important; /* Break words to prevent overflow */
+    overflow-wrap: break-word !important; /* Break long words if necessary */
+  }
+
+span.chatbot > p > img{
+    margin-top:40px !important;
+    max-height: none !important;
+    max-width: 80% !important;
+    border-radius:0px !important;
+}
+
+
+.chatbot-caption{
+    font-size:11px;
+    font-style:italic;
+    color:#508094;
+}
+
+.ai-generated{
+    font-size:11px!important;
+    font-style:italic;
+    color:#73b8d4 !important;
+}
+
+.card-image > .card-content{
+    background-color:#f1f7fa !important;
+}
+
+
+
+.tab-nav > button.selected{
+    color:#4b8ec3;
+    font-weight:bold;
+    border:none;
+}
+
+.tab-nav{
+    border:none !important;
+}
+
+#input-textbox > label > textarea{
+    border-radius:40px;
+    padding-left:30px;
+    resize:none;
+}
+
+#input-message > div{
+    border:none;
+}
+
+#dropdown-samples{
+  /*! border:none !important; */
+  /*! border-width:0px !important; */
+  background:none !important;
+  
+}
+
+#dropdown-samples > .container > .wrap{
+  background-color:white;
+}
+
+
+#tab-examples > div > .form{
+  border:none;
+  background:none !important;
+}
+
+.a-doc-ref{
+	text-decoration: none !important;
+}

utils/generator.py

@@ -0,0 +1,290 @@
+import logging
+import asyncio
+import json
+import ast
+from typing import List, Dict, Any, Union
+from dotenv import load_dotenv
+
+# LangChain imports
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+from langchain_core.messages import SystemMessage, HumanMessage
+
+import os
+import configparser
+
+
+def getconfig(configfile_path: str):
+    """
+    Read the config file
+    Params
+    ----------------
+    configfile_path: file path of .cfg file
+    """
+    config = configparser.ConfigParser()
+    try:
+        config.read_file(open(configfile_path))
+        return config
+    except:
+        logging.warning("config file not found")
+
+# ---------------------------------------------------------------------
+# Provider-agnostic authentication and configuration
+# ---------------------------------------------------------------------
+
+def get_auth(provider: str) -> dict:
+    """Get authentication configuration for different providers"""
+    auth_configs = {
+        "openai": {"api_key": os.getenv("OPENAI_API_KEY")},
+        "huggingface": {"api_key": os.getenv("HF_TOKEN")},
+        "anthropic": {"api_key": os.getenv("ANTHROPIC_API_KEY")},
+        "cohere": {"api_key": os.getenv("COHERE_API_KEY")},
+    }
+    
+    if provider not in auth_configs:
+        raise ValueError(f"Unsupported provider: {provider}")
+    
+    auth_config = auth_configs[provider]
+    api_key = auth_config.get("api_key")
+    
+    if not api_key:
+        raise RuntimeError(f"Missing API key for provider '{provider}'. Please set the appropriate environment variable.")
+    
+    return auth_config
+
+# ---------------------------------------------------------------------
+# Model / client initialization (non exaustive list of providers)
+# ---------------------------------------------------------------------
+
+config = getconfig("model_params.cfg")
+
+PROVIDER = config.get("generator", "PROVIDER")
+MODEL = config.get("generator", "MODEL")
+MAX_TOKENS = int(config.get("generator", "MAX_TOKENS"))
+TEMPERATURE = float(config.get("generator", "TEMPERATURE"))
+INFERENCE_PROVIDER = config.get("generator", "INFERENCE_PROVIDER")
+ORGANIZATION = config.get("generator", "ORGANIZATION")
+
+# Set up authentication for the selected provider
+auth_config = get_auth(PROVIDER)
+
+def get_chat_model():
+    """Initialize the appropriate LangChain chat model based on provider"""
+    common_params = {
+        "temperature": TEMPERATURE,
+        "max_tokens": MAX_TOKENS,
+    }
+    
+    # if PROVIDER == "openai":
+    #     return ChatOpenAI(
+    #         model=MODEL,
+    #         openai_api_key=auth_config["api_key"],
+    #         **common_params
+    #     )
+    # elif PROVIDER == "anthropic":
+    #     return ChatAnthropic(
+    #         model=MODEL,
+    #         anthropic_api_key=auth_config["api_key"],
+    #         **common_params
+    #     )
+    # elif PROVIDER == "cohere":
+    #     return ChatCohere(
+    #         model=MODEL,
+    #         cohere_api_key=auth_config["api_key"],
+    #         **common_params
+    #     )
+    if PROVIDER == "huggingface":
+        # Initialize HuggingFaceEndpoint with explicit parameters
+        llm = HuggingFaceEndpoint(
+            repo_id=MODEL,
+            huggingfacehub_api_token=auth_config["api_key"],
+            task="text-generation",
+            provider=INFERENCE_PROVIDER,     
+            server_kwargs={"bill_to": ORGANIZATION},
+            temperature=TEMPERATURE,
+            max_new_tokens=MAX_TOKENS
+        )
+        return ChatHuggingFace(llm=llm)
+    else:
+        raise ValueError(f"Unsupported provider: {PROVIDER}")
+
+# Initialize provider-agnostic chat model
+chat_model = get_chat_model()
+
+# ---------------------------------------------------------------------
+# Context processing - may need further refinement (i.e. to manage other data sources)
+# ---------------------------------------------------------------------
+# def extract_relevant_fields(retrieval_results: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+#     """
+#     Extract only relevant fields from retrieval results.
+    
+#     Args:
+#         retrieval_results: List of JSON objects from retriever
+        
+#     Returns:
+#         List of processed objects with only relevant fields
+#     """
+
+#     retrieval_results = ast.literal_eval(retrieval_results)
+
+#     processed_results = []
+    
+#     for result in retrieval_results:
+#         # Extract the answer content
+#         answer = result.get('answer', '')
+        
+#         # Extract document identification from metadata
+#         metadata = result.get('answer_metadata', {})
+#         doc_info = {
+#             'answer': answer,
+#             'filename': metadata.get('filename', 'Unknown'),
+#             'page': metadata.get('page', 'Unknown'),
+#             'year': metadata.get('year', 'Unknown'),
+#             'source': metadata.get('source', 'Unknown'),
+#             'document_id': metadata.get('_id', 'Unknown')
+#         }
+        
+#         processed_results.append(doc_info)
+    
+#     return processed_results
+
+# def format_context_from_results(processed_results: List[Dict[str, Any]]) -> str:
+#     """
+#     Format processed retrieval results into a context string for the LLM.
+    
+#     Args:
+#         processed_results: List of processed objects with relevant fields
+        
+#     Returns:
+#         Formatted context string
+#     """
+#     if not processed_results:
+#         return ""
+    
+#     context_parts = []
+    
+#     for i, result in enumerate(processed_results, 1):
+#         doc_reference = f"[Document {i}: {result['filename']}"
+#         if result['page'] != 'Unknown':
+#             doc_reference += f", Page {result['page']}"
+#         if result['year'] != 'Unknown':
+#             doc_reference += f", Year {result['year']}"
+#         doc_reference += "]"
+        
+#         context_part = f"{doc_reference}\n{result['answer']}\n"
+#         context_parts.append(context_part)
+    
+#     return "\n".join(context_parts)
+
+# ---------------------------------------------------------------------
+# Core generation function for both Gradio UI and MCP
+# ---------------------------------------------------------------------
+async def _call_llm(messages: list) -> str:
+    """
+    Provider-agnostic LLM call using LangChain.
+    
+    Args:
+        messages: List of LangChain message objects
+        
+    Returns:
+        Generated response content as string
+    """
+    try:
+        # Use async invoke for better performance
+        response = await chat_model.ainvoke(messages)
+        print(response)
+        return response.content
+        #return response.content.strip()
+    except Exception as e:
+        logging.exception(f"LLM generation failed with provider '{PROVIDER}' and model '{MODEL}': {e}")
+        raise
+
+def build_messages(question: str, context: str) -> list:
+    """
+    Build messages in LangChain format.
+    
+    Args:
+        question: The user's question
+        context: The relevant context for answering
+        
+    Returns:
+        List of LangChain message objects
+    """
+    system_content = (
+        """
+        You are an expert assistant. Your task is to generate accurate, helpful responses using only the 
+        information contained in the "CONTEXT" provided.
+
+        Instructions:
+        - Answer based only on provided context: Use only the information present in the retrieved_paragraphs below. Do not use any external knowledge or make assumptions beyond what is explicitly stated.
+        - Language matching: Respond in the same language as the user's query.
+        - Handle missing information: If the retrieved paragraphs do not contain sufficient information to answer the query, respond with "I don't know" or equivalent in the query language. If information is incomplete, state what you know and acknowledge limitations.
+        - Be accurate and specific: When information is available, provide clear, specific answers. Include relevant details, useful facts, and numbers from the context.
+        - Stay focused: Answer only what is asked. Do not provide additional information not requested.
+        - Structure your response effectively:
+                * Do not just summarize each passage one by one. Group your summaries to highlight the key parts in the explanation.
+                * Use bullet points and lists when it makes sense to improve readability.
+                * You do not need to use every passage. Only use the ones that help answer the question.
+        - Format your response properly: Use markdown formatting (bullet points, numbered lists, headers) to make your response clear and easy to read. Example: <br> for linebreaks 
+        
+        Input Format:
+        - Query: {query}
+        - Retrieved Paragraphs: {retrieved_paragraphs}
+
+        Generate your response based on these guidelines.
+
+        """
+    )
+    
+    user_content = f"### CONTEXT\n{context}\n\n### USER QUESTION\n{question}"
+    
+    return [
+        SystemMessage(content=system_content),
+        HumanMessage(content=user_content)
+    ]
+
+    
+async def generate(query: str, context: Union[str, List[Dict[str, Any]]]) -> str:
+    """
+    Generate an answer to a query using provided context through RAG.
+    
+    This function takes a user query and relevant context, then uses a language model
+    to generate a comprehensive answer based on the provided information.
+    
+    Args:
+        query (str): User query
+        context (list): List of retrieval result objects (dictionaries)
+    Returns:
+        str: The generated answer based on the query and context
+    """
+    if not query.strip():
+        return "Error: Query cannot be empty"
+    
+    # Handle both string context (for Gradio UI) and list context (from retriever)
+    if isinstance(context, list):
+        if not context:
+            return "Error: No retrieval results provided"
+        
+        # # Process the retrieval results
+        # processed_results = extract_relevant_fields(context)
+        formatted_context = context
+   
+        # if not formatted_context.strip():
+            # return "Error: No valid content found in retrieval results"
+    
+    elif isinstance(context, str):
+        if not context.strip():
+            return "Error: Context cannot be empty"
+        formatted_context = context
+    
+    else:
+        return "Error: Context must be either a string or list of retrieval results"
+    
+    try:
+        messages = build_messages(query, formatted_context)
+        answer = await _call_llm(messages)
+
+        return answer
+        
+    except Exception as e:
+        logging.exception("Generation failed")
+        return f"Error: {str(e)}"

utils/logger.py

@@ -0,0 +1,171 @@
+import json
+import logging
+from datetime import datetime
+from uuid import uuid4
+import requests
+from pathlib import Path
+from datasets import load_dataset, Dataset
+import os
+from huggingface_hub import CommitScheduler, HfApi
+import random
+
+class ChatLogger:
+    def __init__(self, scheduler):
+        """Initialize the chat logger with paths and configurations"""
+        if not scheduler:
+            raise ValueError("Scheduler is required")
+            
+        self.scheduler = scheduler
+        self.json_dataset_dir = Path(scheduler.folder_path)
+        
+        # Ensure the directory exists
+        try:
+            self.json_dataset_dir.mkdir(parents=True, exist_ok=True)
+            logging.info(f"Using dataset directory at: {self.json_dataset_dir}")
+        except Exception as e:
+            logging.error(f"Error creating dataset directory: {str(e)}")
+            raise
+        
+        self.logs_path = self.json_dataset_dir / f"logs-{uuid4()}.jsonl"
+        logging.info(f"Log file will be created at: {self.logs_path}")
+
+    def get_client_ip(self, request=None):
+        """Get the client IP address from the request context"""
+        try:
+            if request:
+                # Try different headers that might contain the real IP
+                ip = request.client.host
+                # Check for proxy headers
+                forwarded_for = request.headers.get('X-Forwarded-For')
+                if forwarded_for:
+                    # X-Forwarded-For can contain multiple IPs - first one is the client
+                    ip = forwarded_for.split(',')[0].strip()
+                
+                logging.debug(f"Client IP detected: {ip}")
+                return ip
+        except Exception as e:
+            logging.error(f"Error getting client IP: {e}")
+        return "127.0.0.1"
+
+    def get_client_location(self, ip_address):
+        """Get geolocation info using ipapi.co"""
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+        try:
+            response = requests.get(
+                f'https://ipapi.co/{ip_address}/json/',
+                headers=headers,
+                timeout=5
+            )
+            if response.status_code == 200:
+                data = response.json()
+                # Add random noise between -0.01 and 0.01 degrees (roughly ±1km)
+                lat = data.get('latitude')
+                lon = data.get('longitude')
+                if lat is not None and lon is not None:
+                    lat += random.uniform(-0.01, 0.01)
+                    lon += random.uniform(-0.01, 0.01)
+                
+                return {
+                    'city': data.get('city'),
+                    'region': data.get('region'),
+                    'country': data.get('country_name'),
+                    'latitude': lat,
+                    'longitude': lon
+                }
+            elif response.status_code == 429:
+                logging.warning(f"Rate limit exceeded for IP lookup")
+                return None
+            else:
+                logging.error(f"Error in IP lookup: Status code {response.status_code}")
+                return None
+                
+        except requests.exceptions.RequestException as e:
+            logging.error(f"Request failed in IP lookup: {str(e)}")
+            return None
+
+    def create_log_entry(self, query, answer, retrieved_content, feedback=None, request=None):
+        """Create a structured log entry with all required fields"""
+        timestamp = datetime.now().timestamp()
+        
+        # Get client location if request is provided
+        ip = self.get_client_ip(request) if request else None
+        location = self.get_client_location(ip) if ip else None
+        
+        log_entry = {
+            "record_id": str(uuid4()),
+            "session_id": str(uuid4()),  # In practice, this should be passed in from the session
+            "time": str(timestamp),
+            "client_location": location,
+            "question": query,
+            "answer": answer,
+            "retrieved_content": retrieved_content if isinstance(retrieved_content, list) else [retrieved_content],
+            "feedback": feedback
+        }
+        
+        return log_entry
+
+    def cleanup_local_files(self):
+        """Delete local JSON files after successful upload"""
+        try:
+            # List all files in json_dataset directory
+            for file in self.json_dataset_dir.glob("*.json*"):
+                try:
+                    file.unlink()  # Delete file
+                    logging.info(f"Deleted local file: {file}")
+                except Exception as e:
+                    logging.error(f"Error deleting file {file}: {e}")
+            
+            # Optionally remove the directory if empty
+            if not any(self.json_dataset_dir.iterdir()):
+                self.json_dataset_dir.rmdir()
+                logging.info("Removed empty json_dataset directory")
+        except Exception as e:
+            logging.error(f"Error in cleanup: {e}")
+
+    def save_local(self, log_entry):
+        """Save log entry to local JSONL file"""
+        try:
+            # Ensure parent directory exists
+            self.logs_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Reorder fields for consistency
+            field_order = [
+                "record_id",
+                "session_id",
+                "time",
+                "client_location",
+                "question",
+                "answer",
+                "retrieved_content",
+                "feedback"
+            ]
+            ordered_logs = {k: log_entry.get(k) for k in field_order if k in log_entry}
+            
+            with self.scheduler.lock:
+                with open(self.logs_path, 'a') as f:
+                    json.dump(ordered_logs, f)
+                    f.write('\n')
+                    logging.info(f"Log entry saved to {self.logs_path}")
+                
+                # After successful write, trigger cleanup
+                self.cleanup_local_files()
+            return True
+        except Exception as e:
+            logging.error(f"Error saving to local file: {str(e)}")
+            return False
+
+    def log(self, query, answer, retrieved_content, feedback=None, request=None):
+        """Main logging method that handles both local and HF storage"""
+        # Create log entry
+        log_entry = self.create_log_entry(
+            query=query,
+            answer=answer,
+            retrieved_content=retrieved_content,
+            feedback=feedback,
+            request=request
+        )
+        logging.info("Logging results completed")
+        # Save locally with thread safety
+        return self.save_local(log_entry)

utils/retriever.py

@@ -0,0 +1,29 @@
+import gradio as gr
+from gradio_client import Client
+import logging
+
+def retrieve_paragraphs(query, category = None):
+    """Connect to retriever and retrieve paragraphs"""
+    try:   
+        # Call the API with the uploaded file
+        client = Client("https://giz-chatfed-retriever0-3.hf.space/")
+        print("calling retriever at https://giz-chatfed-retriever0-3.hf.space/", flush=True)
+        logging.info("calling retriever at https://giz-chatfed-retriever0-3.hf.space")
+        filter_metadata = None
+        if category:
+            filter_metadata = {'category': category}
+        result = client.predict(
+                query=query,
+                collection_name= "Humboldt",
+                filter_metadata = filter_metadata,
+                api_name="/retrieve"
+        )
+        return result
+    
+    except Exception as e:
+        error_msg = f"Error retrieving paragraphs: {str(e)}"
+        return (
+                error_msg,
+                gr.update(visible=True),  # upload_status
+                gr.update(visible=False)  # results_table
+            )