feat: switch to deepseek model for token-free operation

README.md

@@ -1,36 +1,27 @@
 ---
-title: DeepSeek Code Assistant
-emoji: 🚀
+title: AI Chat Assistant
+emoji: 💭
 colorFrom: blue
 colorTo: purple
 sdk: streamlit
 sdk_version: 1.41.1
 app_file: app.py
 pinned: false
-short_description: Advanced Code Generation with Enhanced UI
+short_description: ChatGPT-like interface using Ollama
 ---
 
-# DeepSeek Code Assistant Pro
+# AI Chat Assistant
 
-A powerful code generation tool with enhanced UI features:
-- Modern, responsive interface
-- Advanced code customization
-- Multiple template options
-- Syntax highlighting
-- One-click code copying
-- Code downloading
+Simple and efficient chat interface powered by Ollama DeepSeek model.
 
 ## Features
-- Interactive code generation
-- Real-time preview
-- Multiple programming languages
-- Custom templates
-- Error handling options
-- Automatic commenting
-- Test generation
+- Clean chat interface
+- Message history
+- Streaming responses
+- Context awareness
+- Local inference
 
-## Pro Tips
-- Use detailed descriptions
-- Specify requirements clearly
-- Select appropriate templates
-- Enable useful options
+## Usage
+- Type your message and press Enter
+- Clear chat history using sidebar button
+- Maintains conversation context

app.py

@@ -1,354 +1,121 @@
 import streamlit as st
-# Set page config must be the first Streamlit command
-st.set_page_config(
-    page_title="DeepSeek Coding Assistant",
-    page_icon="🚀",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-from transformers import AutoTokenizer, AutoModelForCausalLM
+from transformers import AutoModelForCausalLM, AutoTokenizer
 import torch
-import gc
-from PIL import Image
-import io
 import logging
-import sys
-
-# Set up logging
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
 
-# Debug container after page config
-debug_container = st.empty()
+# Configure page and logging
+st.set_page_config(page_title="AI Chat Assistant", page_icon="💭", layout="wide")
+logging.basicConfig(level=logging.INFO)
 
-def debug_info(msg):
-    logger.debug(msg)
-    if st.session_state.get('show_debug', False):
-        debug_container.info(msg)
-
-# Add custom CSS
+# Custom CSS for chat interface
 st.markdown("""
 <style>
-    .main {
-        padding: 2rem;
-    }
-    .stButton button {
-        width: 100%;
-        border-radius: 5px;
-        height: 3em;
-        background-color: #4CAF50;
-        color: white;
-    }
-    .stTextInput > div > div > input {
-        border-radius: 5px;
-    }
-    .stSelectbox > div > div > select {
-        border-radius: 5px;
-    }
-    .output-container {
-        background-color: #f0f2f6;
-        padding: 20px;
-        border-radius: 10px;
-        margin: 10px 0;
-    }
-    .success-message {
-        color: #4CAF50;
-        font-weight: bold;
-    }
-    .error-message {
-        color: #ff4444;
-        font-weight: bold;
-    }
+    .stChat { padding: 20px; border-radius: 10px; }
+    .user-message { background-color: #e6f3ff; }
+    .assistant-message { background-color: #f0f2f6; }
 </style>
 """, unsafe_allow_html=True)
 
-# Add debug toggle to sidebar
-def create_sidebar():
-    with st.sidebar:
-        st.image("https://raw.githubusercontent.com/streamlit/streamlit/develop/examples/streamlit_app_example.png", 
-                width=100)
-        st.title("🛠️ Settings")
-        
-        # Add debug toggle
-        st.session_state.show_debug = st.checkbox("Show Debug Info", value=False)
-        
-        task = st.selectbox(
-            "Select Task",
-            ["💻 Code Generation", "🖼️ Image Analysis", "📚 Concept Explanation"]
-        )
-        
-        st.markdown("---")
-        
-        if st.button("♻️ Clear Cache", use_container_width=True):
-            st.cache_resource.clear()
-            st.success("Cache cleared successfully!")
-        
-        st.markdown("""
-        ### 🌟 Pro Tips
-        - Use detailed descriptions
-        - Specify edge cases
-        - Include example inputs/outputs
-        """)
-        
-        return task.split()[1]  # Return without emoji
-
 @st.cache_resource
 def load_model():
+    model_name = "deepseek-ai/deepseek-chat-1.3b-base"  # Smaller DeepSeek model
+    
     try:
-        debug_info("Loading model...")
-        model_id = "deepseek-ai/deepseek-coder-1.3b-base"
-        
-        debug_info(f"Initializing tokenizer from {model_id}")
         tokenizer = AutoTokenizer.from_pretrained(
-            model_id,
-            trust_remote_code=True,
-            padding_side='left',
-            truncation_side='left'
+            model_name,
+            trust_remote_code=True
         )
+        tokenizer.pad_token = tokenizer.eos_token
         
-        # Validate tokenizer configuration
-        debug_info(f"Tokenizer pad_token: {tokenizer.pad_token}")
-        debug_info(f"Tokenizer vocab size: {len(tokenizer)}")
-        
-        if not hasattr(tokenizer, 'pad_token') or tokenizer.pad_token is None:
-            debug_info("Setting default pad token")
-            tokenizer.pad_token = '[PAD]'
-        
-        debug_info("Loading model weights...")
         model = AutoModelForCausalLM.from_pretrained(
-            model_id,
+            model_name,
             torch_dtype=torch.float32,
             low_cpu_mem_usage=True,
-            device_map="cpu",
-            max_memory={'cpu': '16GB'}
-        )
+            trust_remote_code=True
+        ).to("cpu")
         
-        # Validate model configuration
-        debug_info(f"Model device: {next(model.parameters()).device}")
-        debug_info(f"Model memory: {torch.cuda.max_memory_allocated() if torch.cuda.is_available() else 'CPU only'}")
-        
-        # Ensure model knows about pad token
-        model.config.pad_token_id = tokenizer.pad_token_id
-        model.config.eos_token_id = tokenizer.eos_token_id
-        model.eval()
-        torch.set_num_threads(8)
-        gc.collect()
         return model, tokenizer
         
     except Exception as e:
-        logger.error(f"Model loading error: {str(e)}")
         st.error(f"Error loading model: {str(e)}")
         st.stop()
 
-def generate_response_streaming(prompt, model, tokenizer, placeholder):
+def generate_response(prompt, model, tokenizer):
     try:
-        debug_info("Starting text generation...")
-        debug_info(f"Input prompt length: {len(prompt)}")
-        
-        # Validate inputs
-        if not all([model, tokenizer, placeholder]):
-            raise ValueError("Missing required components")
-            
-        code_prompt = f"""Write professional code based on the given requirements.
-        Language: {prompt.split('code for:')[0] if 'code for:' in prompt else 'any'}
-        Requirements: {prompt}
+        # Format prompt for DeepSeek chat
+        chat_prompt = f"Human: {prompt}\n\nAssistant: Let me help you with that."
         
-        Here's the implementation:"""
+        inputs = tokenizer(chat_prompt, return_tensors="pt", padding=True)
+        message_placeholder = st.empty()
+        response_text = ""
         
-        # Create input tensors with proper attention masks
-        inputs = tokenizer(
-            code_prompt,
-            return_tensors="pt",
-            padding=True,
-            truncation=True,
-            max_length=1024,
-            add_special_tokens=True,
-            return_attention_mask=True
-        )
-        
-        # Ensure input tensors are properly shaped
-        attention_mask = inputs['attention_mask']
-        input_ids = inputs['input_ids']
-        
-        generated_text = ""
         with torch.inference_mode():
-            while input_ids.shape[1] < 2048:
-                outputs = model.generate(
-                    input_ids=input_ids,
-                    attention_mask=attention_mask,
-                    max_new_tokens=1,  # Generate one token at a time
-                    pad_token_id=tokenizer.pad_token_id,
-                    eos_token_id=tokenizer.eos_token_id,
-                    do_sample=True,
-                    temperature=0.5,
-                    top_p=0.95,
-                    repetition_penalty=1.1,
-                )
-                
-                # Get next token and update tensors
-                next_token = outputs[:, -1:]
-                input_ids = torch.cat([input_ids, next_token], dim=1)
-                attention_mask = torch.ones_like(input_ids)
-                
-                # Update display
-                current_text = tokenizer.decode(input_ids[0], skip_special_tokens=True)
-                generated_text = current_text.replace(code_prompt, "").strip()
-                placeholder.code(generated_text)
-                
-                # Check for completion
-                if next_token[0, 0].item() == tokenizer.eos_token_id:
-                    break
-        
-        # Add validation checks during generation
-        if attention_mask.shape != input_ids.shape:
-            debug_info(f"Shape mismatch - attention: {attention_mask.shape}, ids: {input_ids.shape}")
+            outputs = model.generate(
+                inputs["input_ids"],
+                max_length=512,
+                temperature=0.7,
+                top_p=0.95,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                attention_mask=inputs["attention_mask"],
+                num_return_sequences=1,
+                repetition_penalty=1.2
+            )
             
-        debug_info(f"Generation complete. Output length: {len(generated_text)}")
-        return generated_text
+            response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+            # Extract assistant's response
+            response = response.split("Assistant:")[-1].strip()
+            return response
             
     except Exception as e:
-        logger.error(f"Generation error: {str(e)}")
-        return f"Error: {str(e)}"
+        st.error(f"Error: {str(e)}")
+        return None
 
-def code_generation_ui():
-    debug_info("Initializing UI components")
-    
-    # Validate PROGRAMMING_LANGUAGES is defined
-    if 'PROGRAMMING_LANGUAGES' not in globals():
-        st.error("Programming languages configuration not found")
-        return
-    
-    col1, col2 = st.columns([2, 1])
-    
-    with col1:
-        st.markdown("### 📝 Code Requirements")
-        category = st.selectbox(
-            "Domain",
-            list(PROGRAMMING_LANGUAGES.keys()),
-            help="Select the type of application"
-        )
-        
-        language = st.selectbox(
-            "Language",
-            PROGRAMMING_LANGUAGES[category],
-            help="Choose programming language"
-        )
-        
-        template = st.selectbox(
-            "Template",
-            ["Basic Script", "Function", "Class", "Full Program", "API", "Database"],
-            help="Select code structure"
-        )
-    
-    with col2:
-        st.markdown("### ⚙️ Options")
-        add_comments = st.checkbox("Add Comments", value=True)
-        include_tests = st.checkbox("Include Tests")
-        error_handling = st.checkbox("Error Handling")
-    
-    prompt = st.text_area(
-        "Describe Your Code Requirements",
-        placeholder="Example: Create a function that takes a list of numbers and returns the sum of even numbers...",
-        height=150
-    )
-    
-    col1, col2, col3 = st.columns([1, 1, 1])
-    with col2:
-        generate = st.button("🚀 Generate Code", use_container_width=True)
-    
-    if generate and prompt:
-        debug_info(f"Generating code for language: {language}")
-        debug_info(f"Template: {template}")
-        debug_info(f"Options: comments={add_comments}, tests={include_tests}")
-        
-        st.markdown("### 📋 Generated Code")
-        
-        # Create a placeholder for streaming output
-        code_placeholder = st.empty()
-        
-        with st.spinner("🔮 Generating..."):
-            model, tokenizer = load_model()
-            code = generate_response_streaming(prompt, model, tokenizer, code_placeholder)
-            
-            # After generation complete, show final version with copy/download buttons
-            with st.expander("Final Code", expanded=True):
-                st.code(code, language=language.lower())
-                
-                col1, col2 = st.columns([1, 1])
-                with col1:
-                    st.download_button(
-                        "💾 Download Code",
-                        code,
-                        file_name=f"generated_code.{language.lower()}",
-                        mime="text/plain"
-                    )
-                with col2:
-                    st.button("📋 Copy to Clipboard")
-
-# Add global variables check
-if 'PROGRAMMING_LANGUAGES' not in globals():
-    PROGRAMMING_LANGUAGES = {
-        "Web Development": ["HTML", "CSS", "JavaScript", "TypeScript", "PHP"],
-        "Backend": ["Python", "Java", "C#", "Ruby", "Go", "Node.js"],
-        "Data & ML": ["Python", "R", "SQL", "Julia"],
-        "Mobile": ["Swift", "Kotlin", "Java", "React Native"],
-        "System": ["C", "C++", "Rust", "Shell"]
-    }
-    debug_info("Initialized PROGRAMMING_LANGUAGES")
-
-def handle_text_generation(prompt, task_type="code"):
-    try:
-        model, tokenizer = load_model()
-        placeholder = st.empty()
-        
-        if task_type == "code":
-            prompt = f"""Write professional code based on the given requirements.
-            Requirements: {prompt}"""
-        else:
-            prompt = f"Explain this concept: {prompt}"
-            
-        return generate_response_streaming(prompt, model, tokenizer, placeholder)
-    except Exception as e:
-        debug_info(f"Error in text generation: {str(e)}")
-        return f"Error: {str(e)}"
+def init_chat():
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+        st.session_state.model, st.session_state.tokenizer = load_model()
 
 def main():
-    task = create_sidebar()
+    st.title("💭 AI Chat Assistant")
+    init_chat()
     
-    st.markdown("# 🚀 DeepSeek Coding Assistant")
-    st.markdown("---")
+    # Sidebar with controls
+    with st.sidebar:
+        st.markdown("### Chat Controls")
+        if st.button("🗑️ Clear Chat", use_container_width=True):
+            st.session_state.messages = []
+            st.rerun()
+    
+    # Display chat messages
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
     
-    if task == "Code Generation":
-        code_generation_ui()
-    elif task == "Image Analysis":
-        uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
-        if uploaded_file:
-            image = Image.open(uploaded_file)
-            st.image(image, caption="Uploaded Image")
+    # Chat input
+    if prompt := st.chat_input("Send a message..."):
+        # Add user message
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(prompt)
+        
+        # Generate and display assistant response
+        with st.chat_message("assistant"):
+            context = "\n".join([
+                f"{m['role']}: {m['content']}" 
+                for m in st.session_state.messages[-3:]
+            ])
             
-            analysis_type = st.selectbox(
-                "What would you like to know?",
-                ["Describe Image", "Technical Analysis", "Extract Text"]
+            response = generate_response(
+                context,
+                st.session_state.model,
+                st.session_state.tokenizer
             )
             
-            if st.button("Analyze"):
-                with st.spinner("Analyzing image..."):
-                    response = handle_text_generation(
-                        f"Analyze this image for {analysis_type}:",
-                        task_type="analysis"
-                    )
-                    st.write(response)
-    else:  # Concept Explanation
-        concept = st.text_input("Enter the concept you want to understand:")
-        if st.button("Explain"):
-            if concept:
-                with st.spinner("Generating explanation..."):
-                    response = handle_text_generation(
-                        concept,
-                        task_type="explain"
-                    )
-                    st.markdown(response)
+            if response:
+                st.session_state.messages.append(
+                    {"role": "assistant", "content": response}
+                )
 
 if __name__ == "__main__":
     main()

requirements.txt

@@ -1,28 +1,7 @@
 # Core dependencies
 streamlit>=1.41.1
-watchdog>=3.0.0
-
-# Model and ML
 torch>=2.0.0
-transformers>=4.33.0
+transformers>=4.31.0
 accelerate>=0.21.0
 sentencepiece>=0.1.99
-einops>=0.6.1
-scikit-learn>=1.3.0
-
-# UI enhancements
-streamlit-option-menu>=0.3.2
-streamlit-ace>=0.1.1
-streamlit-extras>=0.3.0
-streamlit-code-editor>=0.1.6
-
-# Image processing
-Pillow>=9.0.0
-
-# Performance optimizations
-rich>=13.5.2
-tqdm>=4.65.0
-numpy>=1.24.0
-
-# Memory management
-psutil>=5.9.0
+einops>=0.6.1