Major Update

app-api.py

@@ -0,0 +1,152 @@
+import streamlit as st
+import requests
+import logging
+from typing import Optional, Dict, Any
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Constants
+DEFAULT_SYSTEM_PROMPT = """You are a friendly Assistant. Provide clear, accurate, and brief answers. 
+Keep responses polite, engaging, and to the point. If unsure, politely suggest alternatives."""
+
+MODEL_OPTIONS = [
+    "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+    "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
+    "deepseek-ai/DeepSeek-R1"
+]
+API_BASE_URL = "https://api-inference.huggingface.co/models/"
+
+# Page configuration
+st.set_page_config(
+    page_title="DeepSeek-AI R1",
+    page_icon="🤖",
+    layout="centered"
+)
+
+def initialize_session_state():
+    """Initialize all session state variables"""
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    if "api_failures" not in st.session_state:
+        st.session_state.api_failures = 0
+
+def configure_sidebar() -> Dict[str, Any]:
+    """Create sidebar components and return settings"""
+    with st.sidebar:
+        st.header("Model Configuration")
+        st.markdown("[Get HuggingFace Token](https://huggingface.co/settings/tokens)")
+
+        return {
+            "model": st.selectbox("Select Model", MODEL_OPTIONS, index=0),
+            "system_message": st.text_area(
+                "System Message",
+                value=DEFAULT_SYSTEM_PROMPT,
+                height=100
+            ),
+            "max_tokens": st.slider("Max Tokens", 10, 4000, 100),
+            "temperature": st.slider("Temperature", 0.1, 4.0, 0.3),
+            "top_p": st.slider("Top-p", 0.1, 1.0, 0.6),
+            "debug_chat": st.toggle("Return Full Text (Debugging Only)")
+        }
+
+def format_deepseek_prompt(system_message: str, user_input: str) -> str:
+    """Format the prompt according to DeepSeek's required structure"""
+    return f"""System: {system_message}
+<|User|>{user_input}<|Assistant|>"""
+
+def query_hf_api(payload: Dict[str, Any], api_url: str) -> Optional[Dict[str, Any]]:
+    """Handle API requests with improved error handling"""
+    headers = {"Authorization": f"Bearer {st.secrets['HF_TOKEN']}"}
+    
+    try:
+        response = requests.post(
+            api_url,
+            headers=headers,
+            json=payload,
+            timeout=30
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.HTTPError as e:
+        logger.error(f"HTTP Error: {e.response.status_code} - {e.response.text}")
+        st.error(f"API Error: {e.response.status_code} - {e.response.text[:200]}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Request failed: {str(e)}")
+        st.error("Connection error. Please check your internet connection.")
+    return None
+
+def handle_chat_interaction(settings: Dict[str, Any]):
+    """Manage chat input/output and API communication"""
+    if prompt := st.chat_input("Type your message..."):
+        # Add user message to history
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        try:
+            with st.spinner("Generating response..."):
+                # Format prompt according to model requirements
+                full_prompt = format_deepseek_prompt(
+                    system_message=settings["system_message"],
+                    user_input=prompt
+                )
+
+                payload = {
+                    "inputs": full_prompt,
+                    "parameters": {
+                        "max_new_tokens": settings["max_tokens"],
+                        "temperature": settings["temperature"],
+                        "top_p": settings["top_p"],
+                        "return_full_text": settings["debug_chat"],
+                    }
+                }
+
+                api_url = f"{API_BASE_URL}{settings['model']}"
+                output = query_hf_api(payload, api_url)
+
+                if output and isinstance(output, list):
+                    if 'generated_text' in output[0]:
+                        response_text = output[0]['generated_text'].strip()
+                        # Remove any remaining special tokens
+                        response_text = response_text.split("\n</think>\n")[0].strip()
+                        
+                        # Display and store response
+                        with st.chat_message("assistant"):
+                            st.markdown(response_text)
+                        st.session_state.messages.append(
+                            {"role": "assistant", "content": response_text}
+                        )
+                        return
+                    
+            # Handle failed responses
+            st.session_state.api_failures += 1
+            if st.session_state.api_failures > 2:
+                st.error("Persistent API failures. Please check your API token and model selection.")
+        
+        except Exception as e:
+            logger.error(f"Unexpected error: {str(e)}", exc_info=True)
+            st.error("An unexpected error occurred. Please try again.")
+
+def display_chat_history():
+    """Render chat message history"""
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+def main():
+    """Main application flow"""
+    initialize_session_state()
+    settings = configure_sidebar()
+    
+    st.title("🤖 DeepSeek Chatbot")
+    st.caption(f"Current Model: {settings['model']}")
+    st.caption("Powered by Hugging Face Inference API - Configure in sidebar")
+    
+    display_chat_history()
+    handle_chat_interaction(settings)
+
+if __name__ == "__main__":
+    main()

app.py

@@ -1,22 +1,14 @@
 import streamlit as st
-import requests
-import logging
-from typing import Optional, Dict, Any
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from typing import Dict, Any
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Constants
+# Configure model (updated for local execution)
 DEFAULT_SYSTEM_PROMPT = """You are a friendly Assistant. Provide clear, accurate, and brief answers. 
 Keep responses polite, engaging, and to the point. If unsure, politely suggest alternatives."""
 
-MODEL_OPTIONS = [
-    "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
-    "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
-    "deepseek-ai/DeepSeek-R1"
-]
-API_BASE_URL = "https://api-inference.huggingface.co/models/"
+MODEL_NAME = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"  # Directly specify model
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
 # Page configuration
 st.set_page_config(
@@ -29,58 +21,67 @@ def initialize_session_state():
     """Initialize all session state variables"""
     if "messages" not in st.session_state:
         st.session_state.messages = []
-    if "api_failures" not in st.session_state:
-        st.session_state.api_failures = 0
+    if "model_loaded" not in st.session_state:
+        st.session_state.update({
+            "model_loaded": False,
+            "model": None,
+            "tokenizer": None
+        })
+
+def load_model():
+    """Load model and tokenizer with quantization"""
+    if not st.session_state.model_loaded:
+        with st.spinner("Loading model (this may take a minute)..."):
+            tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+            model = AutoModelForCausalLM.from_pretrained(
+                MODEL_NAME,
+                trust_remote_code=True,
+                torch_dtype=torch.bfloat16,
+                device_map="auto"
+            )
+            
+            st.session_state.update({
+                "model": model,
+                "tokenizer": tokenizer,
+                "model_loaded": True
+            })
 
 def configure_sidebar() -> Dict[str, Any]:
-    """Create sidebar components and return settings"""
+    """Create sidebar components"""
     with st.sidebar:
-        st.header("Model Configuration")
-        st.markdown("[Get HuggingFace Token](https://huggingface.co/settings/tokens)")
-
+        st.header("Configuration")
         return {
-            "model": st.selectbox("Select Model", MODEL_OPTIONS, index=0),
-            "system_message": st.text_area(
-                "System Message",
-                value=DEFAULT_SYSTEM_PROMPT,
-                height=100
-            ),
-            "max_tokens": st.slider("Max Tokens", 10, 4000, 100),
-            "temperature": st.slider("Temperature", 0.1, 4.0, 0.3),
-            "top_p": st.slider("Top-p", 0.1, 1.0, 0.6),
-            "debug_chat": st.toggle("Return Full Text (Debugging Only)")
+            "system_message": st.text_area("System Message", value=DEFAULT_SYSTEM_PROMPT, height=100),
+            "max_tokens": st.slider("Max Tokens", 10, 4000, 512),
+            "temperature": st.slider("Temperature", 0.1, 1.0, 0.7),
+            "top_p": st.slider("Top-p", 0.1, 1.0, 0.9)
         }
 
-def format_deepseek_prompt(system_message: str, user_input: str) -> str:
-    """Format the prompt according to DeepSeek's required structure"""
-    return f"""System: {system_message}
-<|User|>{user_input}<|Assistant|>"""
+def format_prompt(system_message: str, user_input: str) -> str:
+    """Format prompt according to model's required template"""
+    return f"""<｜begin▁of▁sentence｜>System: {system_message}
+User: {user_input}
+Assistant: """
 
-def query_hf_api(payload: Dict[str, Any], api_url: str) -> Optional[Dict[str, Any]]:
-    """Handle API requests with improved error handling"""
-    headers = {"Authorization": f"Bearer {st.secrets['HF_TOKEN']}"}
+def generate_response(prompt: str, settings: Dict[str, Any]) -> str:
+    """Generate response using local model"""
+    inputs = st.session_state.tokenizer(prompt, return_tensors="pt").to(DEVICE)
+    
+    outputs = st.session_state.model.generate(
+        inputs.input_ids,
+        max_new_tokens=settings["max_tokens"],
+        temperature=settings["temperature"],
+        top_p=settings["top_p"],
+        do_sample=True,
+        pad_token_id=st.session_state.tokenizer.eos_token_id
+    )
     
-    try:
-        response = requests.post(
-            api_url,
-            headers=headers,
-            json=payload,
-            timeout=30
-        )
-        response.raise_for_status()
-        return response.json()
-    except requests.exceptions.HTTPError as e:
-        logger.error(f"HTTP Error: {e.response.status_code} - {e.response.text}")
-        st.error(f"API Error: {e.response.status_code} - {e.response.text[:200]}")
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Request failed: {str(e)}")
-        st.error("Connection error. Please check your internet connection.")
-    return None
+    response = st.session_state.tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return response.split("Assistant:")[-1].strip()
 
 def handle_chat_interaction(settings: Dict[str, Any]):
-    """Manage chat input/output and API communication"""
+    """Manage chat interactions"""
     if prompt := st.chat_input("Type your message..."):
-        # Add user message to history
         st.session_state.messages.append({"role": "user", "content": prompt})
         
         with st.chat_message("user"):
@@ -88,62 +89,33 @@ def handle_chat_interaction(settings: Dict[str, Any]):
 
         try:
             with st.spinner("Generating response..."):
-                # Format prompt according to model requirements
-                full_prompt = format_deepseek_prompt(
-                    system_message=settings["system_message"],
-                    user_input=prompt
+                full_prompt = format_prompt(
+                    settings["system_message"],
+                    prompt
                 )
-
-                payload = {
-                    "inputs": full_prompt,
-                    "parameters": {
-                        "max_new_tokens": settings["max_tokens"],
-                        "temperature": settings["temperature"],
-                        "top_p": settings["top_p"],
-                        "return_full_text": settings["debug_chat"],
-                    }
-                }
-
-                api_url = f"{API_BASE_URL}{settings['model']}"
-                output = query_hf_api(payload, api_url)
-
-                if output and isinstance(output, list):
-                    if 'generated_text' in output[0]:
-                        response_text = output[0]['generated_text'].strip()
-                        # Remove any remaining special tokens
-                        response_text = response_text.split("\n</think>\n")[0].strip()
-                        
-                        # Display and store response
-                        with st.chat_message("assistant"):
-                            st.markdown(response_text)
-                        st.session_state.messages.append(
-                            {"role": "assistant", "content": response_text}
-                        )
-                        return
-                    
-            # Handle failed responses
-            st.session_state.api_failures += 1
-            if st.session_state.api_failures > 2:
-                st.error("Persistent API failures. Please check your API token and model selection.")
+                
+                response = generate_response(full_prompt, settings)
+                
+                with st.chat_message("assistant"):
+                    st.markdown(response)
+                st.session_state.messages.append({"role": "assistant", "content": response})
         
         except Exception as e:
-            logger.error(f"Unexpected error: {str(e)}", exc_info=True)
-            st.error("An unexpected error occurred. Please try again.")
+            st.error(f"Generation error: {str(e)}")
 
 def display_chat_history():
-    """Render chat message history"""
+    """Display chat history"""
     for message in st.session_state.messages:
         with st.chat_message(message["role"]):
             st.markdown(message["content"])
 
 def main():
-    """Main application flow"""
     initialize_session_state()
+    load_model()  # Load model before anything else
     settings = configure_sidebar()
     
-    st.title("🤖 DeepSeek Chatbot")
-    st.caption(f"Current Model: {settings['model']}")
-    st.caption("Powered by Hugging Face Inference API - Configure in sidebar")
+    st.title("🤖 DeepSeek Chatbot (Local)")
+    st.caption(f"Running {MODEL_NAME} directly on {DEVICE.upper()}")
     
     display_chat_history()
     handle_chat_interaction(settings)

packages.txt

@@ -1,2 +0,0 @@
-tesseract-ocr
-tesseract-ocr-eng

requirements.txt

@@ -1,13 +1,4 @@
-streamlit==1.29.0
-requests==2.31.0
-Pillow==10.1.0
-pytesseract==0.3.10
-PyMuPDF==1.23.8
-sentence-transformers==2.2.2
-numpy==1.24.3
-python-multipart==0.0.6
-opencv-python-headless==4.8.1.78
-scikit-learn==1.3.2
-protobuf==4.25.1
-huggingface_hub==0.25.2
-transformers
+torch>=2.0.0
+transformers>=4.40.0
+streamlit>=1.32.0
+accelerate>=0.27.0