Update app, config, README; add tests

.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+.vscode/

LOCALTEST.md

@@ -0,0 +1,18 @@
+# Manual Setup
+
+```bash
+python3 -m venv .venv # Windows: python -m venv .venv
+source .venv/bin/activate  # Windows: .venv\Scripts\activate
+pip install --upgrade pip
+pip install -r requirements.txt
+```
+
+# Test Application
+
+```bash
+python3 test_app.py # Windows: python test_app.py
+# for full test with LLM for Huggingface Spaces deployment
+python3 app.py # Windows: python app.py
+```
+
+Open browser: http://localhost:7860

README.md

@@ -28,37 +28,23 @@ short_description: GeoAI Coding Agent - Geospatial AI Coding Assistant"
 
 # 🌍 GeoAI Coding Agent
 
-A **Geospatial AI Coding Assistant** powered by multiple LLMs via HuggingFace Inference Providers.
+A **Geospatial AI Coding Assistant** powered by `Qwen/Qwen2.5-Coder-7B-Instruct` via HuggingFace Inference API.
 
-Specialized in **GDAL/OGR**, **Rasterio**, **GeoPandas**, **xarray**, and geospatial development across multiple programming languages. Designed for **beginner and intermediate learners** with educational explanations.
+Specialized in **GDAL/OGR**, **Rasterio**, **GeoPandas**, **xarray**, and geospatial development across multiple programming languages.
 
 ![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)
-![Gradio](https://img.shields.io/badge/Gradio-6.3+-orange.svg)
+![Gradio](https://img.shields.io/badge/Gradio-4.19+-orange.svg)
 ![License](https://img.shields.io/badge/License-AGPL--3.0-green.svg)
 
 ## ✨ Features
 
-- **🤖 Multiple AI Models**: Choose from 6 different models (DeepSeek, Kimi, Llama, MiniMax, GLM, Mistral)
 - **🗺️ Geospatial Expertise**: Deep knowledge of GDAL, Rasterio, GeoPandas, PyProj, xarray, and rioxarray
-- **📚 Educational Focus**: Responses include code explanations, step-by-step logic, and tips for beginners
 - **💻 Multi-Language Support**: Python, Java, C/C++, JavaScript, TypeScript, Rust
-- **📥 Download Options**: Export responses as Markdown or code files
+- **📥 Download Options**: Export responses as Markdown, Jupyter Notebooks, or code files
 - **🎨 Code Editor Style UI**: Syntax highlighting with dark theme
+- **🔒 BYOT (Bring Your Own Token)**: Uses your HuggingFace API token for inference
 - **⚡ Streaming Responses**: Real-time token streaming for better UX
 
-## 🤖 Available Models
-
-| Model | Provider | Speed | Best For |
-|-------|----------|-------|----------|
-| **DeepSeek V3.2** | Novita | Medium | Complex geospatial tasks, detailed explanations |
-| **Kimi K2 Instruct** | Novita | Medium | General coding, good balance |
-| **Llama 3.1 8B** | Novita | Fast | Quick answers, simple tasks |
-| **MiniMax M2.1** | Novita | Medium | Creative solutions |
-| **GLM 4.7 Flash** | Novita | Fast | Fast responses, basic tasks |
-| **Mistral 7B v0.2** | Featherless | Fast | Quick prototyping |
-
-> 💡 **Tip**: Larger models provide better results but take longer. Smaller models are faster for simple queries.
-
 ## 🚀 Quick Start
 
 ### Local Development
@@ -136,25 +122,22 @@ geoai-coding-agent/
 
 Key settings in `config.py`:
 
-| Parameter          | Default           | Description                                 |
-| ------------------ | ----------------- | ------------------------------------------- |
-| `DEFAULT_MODEL`    | `DeepSeek V3.2`   | Default model selection                     |
-| `MAX_NEW_TOKENS`   | `2048`            | Maximum response length                     |
-| `TEMPERATURE`      | `0.3`             | Sampling temperature (lower = more focused) |
-| `TOP_P`            | `0.9`             | Nucleus sampling threshold                  |
-| `AVAILABLE_MODELS` | (see table above) | Dictionary of available models & providers  |
+| Parameter        | Default                          | Description                                 |
+| ---------------- | -------------------------------- | ------------------------------------------- |
+| `MODEL_ID`       | `Qwen/Qwen2.5-Coder-7B-Instruct` | HuggingFace model                           |
+| `MAX_NEW_TOKENS` | `2048`                           | Maximum response length                     |
+| `TEMPERATURE`    | `0.3`                            | Sampling temperature (lower = more focused) |
+| `TOP_P`          | `0.9`                            | Nucleus sampling threshold                  |
 
 ## 🔑 API Token
 
-This application requires a **HuggingFace API token** with Inference Provider permissions.
-
-**Required permissions**:
-- ✅ Make calls to Inference Providers
+This application requires a **HuggingFace API token** for inference. This design:
+- ✅ Keeps the Space free (no server-side costs)
+- ✅ Prevents token limit overflow
+- ✅ Gives users control over their usage
 
 Get your free token at: [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
 
-For HuggingFace Spaces deployment, add the token as a **Secret** named `HF_TOKEN` in Space Settings.
-
 ## 🛠️ Supported Languages
 
 | Language   | Extension    | Use Case                      |
@@ -175,22 +158,34 @@ For HuggingFace Spaces deployment, add the token as a **Secret** named `HF_TOKEN
 ## 🙏 Acknowledgments
 
 - Inspired by [GeoAI-Assistance-Ext](https://github.com/rifatSDAS/GeoAI-Assistance-Ext) VS Code Extension
-- Powered by multiple LLMs via [HuggingFace Inference Providers](https://huggingface.co/docs/huggingface_hub/guides/inference)
+- Powered by [Qwen2.5-Coder](https://huggingface.co/Qwen/Qwen2.5-Coder-7B-Instruct)
 - Built with [Gradio](https://gradio.app/)
 
 ## About the Developer
 
-Built by Dr. Kazi Rifat Ahmed, a Full Stack Geospatial AI Engineer, Co-founder and Technical Lead for Satellite Data Services business in Space sector.
+Built by Dr. Kazi Rifat Ahmed, a **Full Stack Geospatial AI Engineer** specializing in:
+- AI/ML-DL for geospatial applications
+- Cloud-native geospatial software engineering & architecture
+- Large-scale Satellite/Earth Observation data data analysis, processing, analytics, and visualization
+- Blockchain and Quantum Computing for geospatial applications
+- Research Advanced Geospatial Science, Technology, and Applications
+- Co-founder and Technical Lead for Satellite Data Services business in Space sector, i.e., QuentuED (https://quentued.de) and Sensor Aktor (https://sensor-aktor.de)
 
-## Contributing
+### Tech Stack Proficiency
+Python | Java | JavaScript | TypeScript | C/C++ | Bash | Cloud-Native Architecture (kubernetes) | DevOps | AI/ML/DL | MLOps | LLM Integration | Blockchain | Remote Sensing Science & Technology | Geospatial Data Science & Engineering
 
-Contributions welcome! Please feel free to submit issues and pull requests.
+### Research Interests
+Geospatial AI | Satellite Data Engineering | Drone Sensors | Geospatial Big Data Analytics | Earth Observation Systems & Sensors | Advanced Remote Sensing Techniques | Space Technology | Quantum Computing | Blockchain | | Satellite Data Services | Planetary Science & Exploration
 
-## Contact
+## 🤝 Contributing
 
-For collaboration opportunities in satellite data services & applications, large-scale satellite data analytics, geospatial AI, blockchain & quantum computing for geospatial applications, or advanced geospatial science, technology & applications, feel free to reach out!
+Contributions are welcome! Please:
 
-Portfolio at https://rifatsdas.github.io/
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Run tests: `pytest test_app.py -v`
+5. Submit a pull request
 
 ## 📄 License
 
@@ -198,6 +193,10 @@ This project is licensed under the **GNU Affero General Public License v3.0** (A
 
 See [LICENSE](LICENSE.md) for details.
 
+## Contact
+
+For collaboration opportunities in satellite data services & applications, large-scale satellite data analytics, geospatial AI, blockchain & quantum computing for geospatial applications, or advanced geospatial science, technology & applications, feel free to reach out!
+
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -18,29 +18,25 @@ from typing import Generator, Tuple, Optional
 HF_TOKEN = os.environ.get("HF_TOKEN", "")
 
 from config import (
-    AVAILABLE_MODELS,
-    DEFAULT_MODEL,
+    MODEL_ID,
     MAX_NEW_TOKENS,
-    MAX_TOKENS_UI_LIMIT,
     TEMPERATURE,
     TOP_P,
     REPETITION_PENALTY,
     SUPPORTED_LANGUAGES,
     SYSTEM_PROMPT,
     EXAMPLE_PROMPTS,
+    NOTEBOOK_TEMPLATE,
     MARKDOWN_TEMPLATE,
 )
 
 
-def create_client(provider: str) -> Optional[InferenceClient]:
-    """Create HuggingFace Inference client with specified provider."""
+def create_client() -> Optional[InferenceClient]:
+    """Create HuggingFace Inference client with environment token."""
     if not HF_TOKEN:
         return None
     try:
-        return InferenceClient(
-            provider=provider,
-            api_key=HF_TOKEN,
-        )
+        return InferenceClient(model=MODEL_ID, token=HF_TOKEN)
     except Exception as e:
         print(f"Error creating client: {e}")
         return None
@@ -73,8 +69,6 @@ def extract_code_blocks(text: str) -> list[dict]:
 def generate_response(
     message: str,
     history: list,
-    model_name: str = DEFAULT_MODEL,
-    max_tokens: int = MAX_NEW_TOKENS,
 ) -> Generator[str, None, None]:
     """Generate streaming response from the model."""
     
@@ -82,12 +76,7 @@ def generate_response(
         yield "⚠️ **Error**: Server configuration error. Please contact the administrator."
         return
     
-    # Get model config
-    model_config = AVAILABLE_MODELS.get(model_name, AVAILABLE_MODELS[DEFAULT_MODEL])
-    model_id = model_config["model_id"]
-    provider = model_config["provider"]
-    
-    client = create_client(provider)
+    client = create_client()
     if client is None:
         yield "⚠️ **Error**: Failed to initialize the model client. Please try again later."
         return
@@ -106,9 +95,8 @@ def generate_response(
     try:
         response_text = ""
         stream = client.chat_completion(
-            model=model_id,
             messages=messages,
-            max_tokens=max_tokens,
+            max_tokens=MAX_NEW_TOKENS,
             temperature=TEMPERATURE,
             top_p=TOP_P,
             stream=True,
@@ -122,15 +110,10 @@ def generate_response(
                 
     except Exception as e:
         error_msg = str(e)
-        print(f"[DEBUG] Full error: {error_msg}")  # Log full error for debugging
         if "401" in error_msg or "unauthorized" in error_msg.lower():
-            yield f"⚠️ **Authentication Error**: The model API returned 401. This could mean:\n\n1. The model `{model_id}` may require accepting terms at the model page\n2. The model may have been gated or moved\n3. Token permissions issue\n\n**Debug info**: {error_msg[:200]}"
+            yield "⚠️ **Authentication Error**: Invalid HuggingFace token. Please check your API token."
         elif "429" in error_msg or "rate" in error_msg.lower():
             yield "⚠️ **Rate Limit**: Too many requests. Please wait a moment and try again."
-        elif "503" in error_msg or "loading" in error_msg.lower():
-            yield "⚠️ **Model Loading**: The model is currently loading. Please try again in a few seconds."
-        elif "404" in error_msg:
-            yield f"⚠️ **Model Not Found**: The model `{model_id}` is not available on provider `{provider}`. Try selecting a different model."
         else:
             yield f"⚠️ **Error**: {error_msg}"
 
@@ -152,6 +135,24 @@ def create_download_file(
             content = MARKDOWN_TEMPLATE.format(query=query, response=response)
             filename = f"geoai_response_{timestamp}.md"
             
+        elif file_format == "notebook":
+            code_blocks = extract_code_blocks(response)
+            if not code_blocks:
+                # If no code blocks, create a markdown cell
+                code_cells = json.dumps([f"# No code blocks found\\n# Response:\\n# {response[:500]}..."])
+            else:
+                # Create code cells from extracted blocks
+                cells = [block["code"] for block in code_blocks if block["language"] == "python"]
+                if not cells:
+                    cells = [code_blocks[0]["code"]] if code_blocks else ["# No Python code found"]
+                code_cells = json.dumps(cells)
+            
+            content = NOTEBOOK_TEMPLATE.format(
+                query=query.replace('"', '\\"').replace('\n', '\\n'),
+                code_cells=code_cells
+            )
+            filename = f"geoai_notebook_{timestamp}.ipynb"
+            
         elif file_format == "code":
             code_blocks = extract_code_blocks(response)
             if not code_blocks:
@@ -183,6 +184,11 @@ def download_as_markdown(response: str, query: str) -> Optional[str]:
     return create_download_file(response, query, "markdown")
 
 
+def download_as_notebook(response: str, query: str) -> Optional[str]:
+    """Download response as Jupyter Notebook."""
+    return create_download_file(response, query, "notebook")
+
+
 def download_as_code(response: str, query: str) -> Optional[str]:
     """Download response as code file."""
     return create_download_file(response, query, "code")
@@ -247,36 +253,18 @@ def create_app():
         gr.Markdown(
             """
             # 🌍 GeoAI Coding Agent
-            ### Geospatial AI Coding Assistant
+            ### Geospatial AI Coding Assistant powered by Qwen2.5-Coder-7B
             
             Expert in **GDAL/OGR**, **Rasterio**, **GeoPandas**, **xarray**, and geospatial development.
             Fluent in Python, Java, C/C++, JavaScript, TypeScript, and Rust.
             """
         )
         
-        # Model Selection
-        with gr.Row():
-            model_selector = gr.Dropdown(
-                choices=list(AVAILABLE_MODELS.keys()),
-                value=DEFAULT_MODEL,
-                label="🤖 Select Model",
-                info="💡 Larger models (DeepSeek, Kimi, MiniMax) take longer than smaller models (Llama, Mistral, GLM) which are faster.",
-                scale=2,
-            )
-            max_tokens_slider = gr.Slider(
-                minimum=1024,
-                maximum=MAX_TOKENS_UI_LIMIT,
-                value=MAX_NEW_TOKENS,
-                step=1024,
-                label="📝 Max Tokens",
-                info="Increase for longer responses from reasoning models",
-                scale=1,
-            )
-        
         # Main Chat Interface
         chatbot = gr.Chatbot(
             label="GeoAI Conversation",
             height=500,
+            type="messages",
         )
         
         # Input Row
@@ -314,6 +302,7 @@ def create_app():
         gr.Markdown("### 📥 Download Response")
         with gr.Row():
             download_md_btn = gr.Button("📄 Markdown", size="sm")
+            download_nb_btn = gr.Button("📓 Notebook", size="sm")
             download_code_btn = gr.Button("💻 Code File", size="sm")
         
         download_file = gr.File(label="Download", visible=False)
@@ -329,7 +318,7 @@ def create_app():
                 return "", history
             return "", history + [{"role": "user", "content": message}]
         
-        def bot_response(history, selected_model, max_tokens):
+        def bot_response(history):
             """Generate bot response with streaming."""
             if not history:
                 return history, "", ""
@@ -339,8 +328,6 @@ def create_app():
             for response in generate_response(
                 user_msg, 
                 history[:-1],
-                selected_model,
-                int(max_tokens),
             ):
                 yield history + [{"role": "assistant", "content": response}], response, user_msg
         
@@ -357,6 +344,13 @@ def create_app():
                 return gr.File(value=filepath, visible=True)
             return gr.File(visible=False)
         
+        def handle_download_nb(response, query):
+            """Handle notebook download."""
+            filepath = download_as_notebook(response, query)
+            if filepath:
+                return gr.File(value=filepath, visible=True)
+            return gr.File(visible=False)
+        
         def handle_download_code(response, query):
             """Handle code file download."""
             filepath = download_as_code(response, query)
@@ -372,7 +366,7 @@ def create_app():
             queue=False,
         ).then(
             bot_response,
-            [chatbot, model_selector, max_tokens_slider],
+            [chatbot],
             [chatbot, last_response, last_query],
         )
         
@@ -383,7 +377,7 @@ def create_app():
             queue=False,
         ).then(
             bot_response,
-            [chatbot, model_selector, max_tokens_slider],
+            [chatbot],
             [chatbot, last_response, last_query],
         )
         
@@ -398,6 +392,12 @@ def create_app():
             [download_file],
         )
         
+        download_nb_btn.click(
+            handle_download_nb,
+            [last_response, last_query],
+            [download_file],
+        )
+        
         download_code_btn.click(
             handle_download_code,
             [last_response, last_query],

config.py

@@ -2,45 +2,12 @@
 GeoAI Coding Agent - Configuration
 ===================================
 Configuration settings for the Geospatial AI Coding Assistant.
-Supports multiple models via HuggingFace Inference Providers.
+Uses Qwen/Qwen2.5-Coder-7B-Instruct via HuggingFace Inference API.
 """
 
-# Available Models with their Inference Providers
-# Format: {display_name: {"model_id": str, "provider": str}}
-AVAILABLE_MODELS = {
-    "DeepSeek V3.2": {
-        "model_id": "deepseek-ai/DeepSeek-V3.2",
-        "provider": "novita",
-    },
-    "Kimi K2 Instruct": {
-        "model_id": "moonshotai/Kimi-K2-Instruct",
-        "provider": "novita",
-    },
-    "Llama 3.1 8B": {
-        "model_id": "meta-llama/Llama-3.1-8B-Instruct",
-        "provider": "novita",
-    },
-    "MiniMax M2.1": {
-        "model_id": "MiniMaxAI/MiniMax-M2.1",
-        "provider": "novita",
-    },
-    "GLM 4.7 Flash": {
-        "model_id": "zai-org/GLM-4.7-Flash",
-        "provider": "novita",
-    },
-    "Mistral 7B v0.2": {
-        "model_id": "mistralai/Mistral-7B-Instruct-v0.2",
-        "provider": "featherless-ai",
-    },
-}
-
-# Default model selection
-DEFAULT_MODEL = "DeepSeek V3.2"
-
-# Generation Parameters
-# Increased for reasoning models that need more tokens for thinking + answer
-MAX_NEW_TOKENS = 16384
-MAX_TOKENS_UI_LIMIT = 32768  # Maximum allowed via UI slider
+# Model Configuration
+MODEL_ID = "Qwen/Qwen2.5-Coder-7B-Instruct"
+MAX_NEW_TOKENS = 2048
 TEMPERATURE = 0.3
 TOP_P = 0.9
 REPETITION_PENALTY = 1.1
@@ -60,7 +27,7 @@ SUPPORTED_LANGUAGES = {
 }
 
 # Geospatial System Prompt
-SYSTEM_PROMPT = """You are GeoAI Coding Agent, an expert Geospatial Software Engineer and educator specialized in:
+SYSTEM_PROMPT = """You are GeoAI Coding Agent, an expert Geospatial Software Engineer specialized in:
 
 ## Core Expertise
 - **GDAL/OGR**: Raster/vector processing, format conversions, coordinate transformations
@@ -73,39 +40,22 @@ SYSTEM_PROMPT = """You are GeoAI Coding Agent, an expert Geospatial Software Eng
 Python, Java, C/C++, JavaScript, TypeScript, Rust
 
 ## Response Guidelines
-Your audience includes beginner and intermediate learners. Provide educational yet practical responses.
-
-1. **Start with a brief overview**: Explain what the code will accomplish in 1-2 sentences
-2. **Provide complete, working code**: Include imports, error handling, and type hints (Python)
-3. **Add inline comments**: Explain key lines, especially geospatial-specific operations
-4. **Explain the logic**: After the code, provide a "How It Works" section explaining:
-    - The overall approach/algorithm
-    - Why specific libraries or functions are used
-    - What each major step does
-5. **Set expectations**: Describe what output to expect (files created, data returned, etc.)
-6. **Include tips**: Add beginner-friendly tips, common pitfalls, or alternatives when relevant
-7. **Format code blocks** with language specification: ```python, ```java, ```cpp, etc.
+1. **Be concise**: Provide working code with minimal but meaningful explanations
+2. **Code first**: Lead with the solution, explain key points after
+3. **Best practices**: Include error handling, type hints (Python), and memory efficiency
+4. **Geospatial focus**: Optimize for large Earth Observation datasets
+5. **Format code blocks** with language specification: ```python, ```java, ```cpp, etc.
 
 ## Response Structure
-### What This Code Does
-Brief overview of the solution.
-
 ```[language]
-# Well-commented code here
+# Your code here
 ```
 
-### How It Works
-1. **Step 1 name**: Explanation of what this step does and why
-2. **Step 2 name**: Continue with key steps...
-
-### What to Expect
-- Describe the output (files, data structures, visualizations)
-- Any dependencies to install
-
-### 💡 Tips for Beginners
-- Helpful tips, common mistakes to avoid, or alternative approaches
+**Key Points:**
+- Brief explanation of the approach (2-3 sentences max)
+- Any important caveats or dependencies
 
-Be thorough but not overwhelming. Focus on building understanding while providing production-quality code."""
+Do NOT include lengthy introductions or excessive explanations. Users are professionals who need working code quickly."""
 
 # Example prompts for UI
 EXAMPLE_PROMPTS = [
@@ -121,40 +71,40 @@ EXAMPLE_PROMPTS = [
 
 # File download templates
 NOTEBOOK_TEMPLATE = '''{{
-    "cells": [
-    {{
-    "cell_type": "markdown",
-    "metadata": {{}},
-    "source": [
-        "# GeoAI Generated Code\\n",
-        "\\n",
-        "Generated by GeoAI Coding Agent\\n",
-        "\\n",
-        "## Query\\n",
-        "{query}"
-    ]
-    }},
-    {{
-    "cell_type": "code",
-    "execution_count": null,
-    "metadata": {{}},
-    "outputs": [],
-    "source": {code_cells}
-    }}
-    ],
-    "metadata": {{
-    "kernelspec": {{
-    "display_name": "Python 3",
-    "language": "python",
-    "name": "python3"
-    }},
-    "language_info": {{
-    "name": "python",
-    "version": "3.10.0"
-    }}
-    }},
-    "nbformat": 4,
-    "nbformat_minor": 4
+ "cells": [
+  {{
+   "cell_type": "markdown",
+   "metadata": {{}},
+   "source": [
+    "# GeoAI Generated Code\\n",
+    "\\n",
+    "Generated by GeoAI Coding Agent\\n",
+    "\\n",
+    "## Query\\n",
+    "{query}"
+   ]
+  }},
+  {{
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {{}},
+   "outputs": [],
+   "source": {code_cells}
+  }}
+ ],
+ "metadata": {{
+  "kernelspec": {{
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  }},
+  "language_info": {{
+   "name": "python",
+   "version": "3.10.0"
+  }}
+ }},
+ "nbformat": 4,
+ "nbformat_minor": 4
 }}'''
 
 MARKDOWN_TEMPLATE = """# GeoAI Generated Code

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+filterwarnings =
+    ignore::pytest.PytestAssertRewriteWarning

test_app.py

@@ -0,0 +1,349 @@
+"""
+GeoAI Coding Agent - Test Suite
+================================
+Unit tests for the GeoAI Coding Agent application.
+Run with: pytest test_app.py -v
+"""
+
+import pytest
+import json
+import os
+import tempfile
+from unittest.mock import Mock, patch, MagicMock
+
+# Import modules to test
+from config import (
+    MODEL_ID,
+    SYSTEM_PROMPT,
+    SUPPORTED_LANGUAGES,
+    EXAMPLE_PROMPTS,
+    NOTEBOOK_TEMPLATE,
+    MARKDOWN_TEMPLATE,
+)
+from app import (
+    create_client,
+    extract_code_blocks,
+    create_download_file,
+    download_as_markdown,
+    download_as_notebook,
+    download_as_code,
+)
+
+
+class TestConfig:
+    """Test configuration settings."""
+    
+    def test_model_id_is_set(self):
+        """Verify model ID is configured."""
+        assert MODEL_ID == "Qwen/Qwen2.5-Coder-7B-Instruct"
+    
+    def test_system_prompt_contains_geospatial_keywords(self):
+        """Verify system prompt includes geospatial expertise."""
+        keywords = ["GDAL", "Rasterio", "GeoPandas", "PyProj", "xarray"]
+        for keyword in keywords:
+            assert keyword in SYSTEM_PROMPT, f"Missing keyword: {keyword}"
+    
+    def test_supported_languages(self):
+        """Verify all required languages are supported."""
+        required_languages = ["python", "java", "cpp", "javascript", "typescript", "rust"]
+        for lang in required_languages:
+            assert lang in SUPPORTED_LANGUAGES, f"Missing language: {lang}"
+            assert "extension" in SUPPORTED_LANGUAGES[lang]
+            assert "highlight" in SUPPORTED_LANGUAGES[lang]
+    
+    def test_example_prompts_not_empty(self):
+        """Verify example prompts are provided."""
+        assert len(EXAMPLE_PROMPTS) > 0
+        for prompt in EXAMPLE_PROMPTS:
+            assert len(prompt) > 10, "Example prompt too short"
+    
+    def test_notebook_template_valid_json_structure(self):
+        """Verify notebook template has valid structure."""
+        # Test with sample data
+        test_template = NOTEBOOK_TEMPLATE.format(
+            query="Test query",
+            code_cells='["print(\\"hello\\")"]'
+        )
+        # Should be valid JSON
+        parsed = json.loads(test_template)
+        assert "cells" in parsed
+        assert "nbformat" in parsed
+
+
+class TestCodeExtraction:
+    """Test code block extraction functionality."""
+    
+    def test_extract_single_python_block(self):
+        """Extract a single Python code block."""
+        text = """Here's the code:
+```python
+import rasterio
+with rasterio.open('test.tif') as src:
+    data = src.read()
+```
+That's it!"""
+        
+        blocks = extract_code_blocks(text)
+        assert len(blocks) == 1
+        assert blocks[0]["language"] == "python"
+        assert "import rasterio" in blocks[0]["code"]
+        assert blocks[0]["extension"] == ".py"
+    
+    def test_extract_multiple_blocks(self):
+        """Extract multiple code blocks with different languages."""
+        text = """Python version:
+```python
+import gdal
+ds = gdal.Open('file.tif')
+```
+
+JavaScript version:
+```javascript
+const fs = require('fs');
+console.log('Hello');
+```
+"""
+        blocks = extract_code_blocks(text)
+        assert len(blocks) == 2
+        assert blocks[0]["language"] == "python"
+        assert blocks[1]["language"] == "javascript"
+    
+    def test_extract_cpp_block(self):
+        """Extract C++ code block."""
+        text = """```cpp
+#include <gdal/gdal.h>
+int main() {
+    GDALAllRegister();
+    return 0;
+}
+```"""
+        blocks = extract_code_blocks(text)
+        assert len(blocks) == 1
+        assert blocks[0]["language"] == "cpp"
+        assert blocks[0]["extension"] == ".cpp"
+    
+    def test_extract_rust_block(self):
+        """Extract Rust code block."""
+        text = """```rust
+fn main() {
+    println!("Hello, GeoAI!");
+}
+```"""
+        blocks = extract_code_blocks(text)
+        assert len(blocks) == 1
+        assert blocks[0]["language"] == "rust"
+        assert blocks[0]["extension"] == ".rs"
+    
+    def test_extract_no_language_defaults_to_python(self):
+        """Code block without language specification defaults to python."""
+        text = """```
+print("hello")
+```"""
+        blocks = extract_code_blocks(text)
+        assert len(blocks) == 1
+        assert blocks[0]["language"] == "python"
+    
+    def test_extract_empty_text(self):
+        """Handle empty text gracefully."""
+        blocks = extract_code_blocks("")
+        assert len(blocks) == 0
+    
+    def test_extract_no_code_blocks(self):
+        """Handle text without code blocks."""
+        blocks = extract_code_blocks("Just some plain text without any code.")
+        assert len(blocks) == 0
+
+
+class TestDownloadFunctions:
+    """Test file download generation."""
+    
+    def test_download_as_markdown(self):
+        """Test markdown file generation."""
+        response = "Here's some code:\n```python\nprint('hello')\n```"
+        query = "Test query"
+        
+        filepath = download_as_markdown(response, query)
+        
+        assert filepath is not None
+        assert filepath.endswith(".md")
+        assert os.path.exists(filepath)
+        
+        with open(filepath, "r") as f:
+            content = f.read()
+        
+        assert "Test query" in content
+        assert "GeoAI" in content
+        
+        # Cleanup
+        os.remove(filepath)
+    
+    def test_download_as_notebook(self):
+        """Test Jupyter notebook file generation."""
+        response = "```python\nimport rasterio\nprint('hello')\n```"
+        query = "Test notebook"
+        
+        filepath = download_as_notebook(response, query)
+        
+        assert filepath is not None
+        assert filepath.endswith(".ipynb")
+        assert os.path.exists(filepath)
+        
+        with open(filepath, "r") as f:
+            content = json.load(f)
+        
+        assert "cells" in content
+        assert content["nbformat"] == 4
+        
+        # Cleanup
+        os.remove(filepath)
+    
+    def test_download_as_code_python(self):
+        """Test Python code file generation."""
+        response = "```python\nimport gdal\nds = gdal.Open('test.tif')\n```"
+        query = "Open a GeoTIFF"
+        
+        filepath = download_as_code(response, query)
+        
+        assert filepath is not None
+        assert filepath.endswith(".py")
+        assert os.path.exists(filepath)
+        
+        with open(filepath, "r") as f:
+            content = f.read()
+        
+        assert "import gdal" in content
+        
+        # Cleanup
+        os.remove(filepath)
+    
+    def test_download_as_code_cpp(self):
+        """Test C++ code file generation."""
+        response = "```cpp\n#include <iostream>\nint main() { return 0; }\n```"
+        query = "C++ example"
+        
+        filepath = download_as_code(response, query)
+        
+        assert filepath is not None
+        assert filepath.endswith(".cpp")
+        
+        # Cleanup
+        os.remove(filepath)
+    
+    def test_download_empty_response(self):
+        """Handle empty response gracefully."""
+        filepath = download_as_markdown("", "query")
+        assert filepath is None
+    
+    def test_download_no_code_blocks(self):
+        """Handle response without code blocks for code download."""
+        filepath = download_as_code("Just text, no code", "query")
+        assert filepath is None
+
+
+class TestClientCreation:
+    """Test HuggingFace client creation."""
+    
+    def test_create_client_no_env_token(self):
+        """No HF_TOKEN env var should return None."""
+        import app
+        original_token = app.HF_TOKEN
+        app.HF_TOKEN = ""
+        client = create_client()
+        app.HF_TOKEN = original_token
+        assert client is None
+    
+    @patch('app.InferenceClient')
+    def test_create_client_with_env_token(self, mock_client):
+        """With HF_TOKEN env var should create client."""
+        import app
+        original_token = app.HF_TOKEN
+        app.HF_TOKEN = "hf_validtoken123"
+        
+        mock_instance = MagicMock()
+        mock_client.return_value = mock_instance
+        
+        client = create_client()
+        
+        app.HF_TOKEN = original_token
+        assert client is not None
+        mock_client.assert_called_once()
+
+
+class TestGeospatialPrompts:
+    """Test geospatial-specific functionality."""
+    
+    def test_gdal_keywords_in_examples(self):
+        """Verify GDAL-related examples exist."""
+        gdal_found = any("GDAL" in p or "gdal" in p.lower() for p in EXAMPLE_PROMPTS)
+        assert gdal_found, "No GDAL examples found"
+    
+    def test_rasterio_keywords_in_examples(self):
+        """Verify Rasterio examples exist."""
+        rasterio_found = any("rasterio" in p.lower() for p in EXAMPLE_PROMPTS)
+        assert rasterio_found, "No Rasterio examples found"
+    
+    def test_geopandas_keywords_in_examples(self):
+        """Verify GeoPandas examples exist."""
+        geopandas_found = any(
+            "geopandas" in p.lower() or "geodataframe" in p.lower() 
+            for p in EXAMPLE_PROMPTS
+        )
+        assert geopandas_found, "No GeoPandas examples found"
+    
+    def test_cog_or_cloud_native_in_examples(self):
+        """Verify cloud-native geospatial examples exist."""
+        cog_found = any(
+            "cog" in p.lower() or "cloud" in p.lower() or "xarray" in p.lower()
+            for p in EXAMPLE_PROMPTS
+        )
+        assert cog_found, "No cloud-native geospatial examples found"
+
+
+class TestIntegration:
+    """Integration tests (require mocking or real API)."""
+    
+    def test_full_workflow_mock(self):
+        """Test full workflow with mocked API."""
+        # Simulate a response
+        mock_response = """Here's how to read a GeoTIFF:
+
+```python
+import rasterio
+
+with rasterio.open('image.tif') as src:
+    data = src.read()
+    profile = src.profile
+    
+print(f"Shape: {data.shape}")
+print(f"CRS: {src.crs}")
+```
+
+**Key Points:**
+- Uses context manager for safe file handling
+- Reads all bands into numpy array
+"""
+        
+        # Test extraction
+        blocks = extract_code_blocks(mock_response)
+        assert len(blocks) == 1
+        assert blocks[0]["language"] == "python"
+        
+        # Test markdown download
+        md_path = download_as_markdown(mock_response, "Read GeoTIFF")
+        assert md_path is not None
+        os.remove(md_path)
+        
+        # Test notebook download
+        nb_path = download_as_notebook(mock_response, "Read GeoTIFF")
+        assert nb_path is not None
+        os.remove(nb_path)
+        
+        # Test code download
+        code_path = download_as_code(mock_response, "Read GeoTIFF")
+        assert code_path is not None
+        os.remove(code_path)
+
+
+# Run tests
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])