geomind-ai 1.1.0__tar.gz → 1.2.0__tar.gz

{geomind_ai-1.1.0 → geomind_ai-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geomind-ai
-Version: 1.1.0
+Version: 1.2.0
 Summary: AI agent for geospatial analysis with Sentinel-2 satellite imagery
 Author: Harsh Shinde, Rajat Shinde
 License-Expression: MIT

{geomind_ai-1.1.0 → geomind_ai-1.2.0}/geomind/__init__.py

@@ -3,7 +3,7 @@ GeoMind - Geospatial AI Agent
 
 """
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 __author__ = "Harsh Shinde, Rajat Shinde"
 
 from .agent import GeoMindAgent

geomind_ai-1.2.0/geomind/agent.py

@@ -0,0 +1,218 @@
+"""
+GeoMind Agent - Simplified AI agent for satellite imagery analysis.
+"""
+
+import json
+from typing import Optional
+from datetime import datetime
+from openai import OpenAI
+
+from .config import OPENROUTER_API_KEY, OPENROUTER_API_URL, OPENROUTER_MODEL
+from .tools import (
+    list_recent_imagery,
+    create_rgb_composite,
+    calculate_ndvi,
+    search_imagery,
+    get_bbox_from_location,
+    geocode_location,
+    get_item_details,
+    get_band_statistics,
+)
+
+# Tool function mapping
+TOOL_FUNCTIONS = {
+    "list_recent_imagery": list_recent_imagery,
+    "create_rgb_composite": create_rgb_composite,
+    "calculate_ndvi": calculate_ndvi,
+    "search_imagery": search_imagery,
+    "get_bbox_from_location": get_bbox_from_location,
+    "geocode_location": geocode_location,
+    "get_item_details": get_item_details,
+    "get_band_statistics": get_band_statistics,
+}
+
+# Simplified tool definitions
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "list_recent_imagery",
+            "description": "Find recent Sentinel-2 imagery for a location",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location_name": {"type": "string", "description": "Location name"},
+                    "days": {"type": "integer", "description": "Days to look back (default: 14)"},
+                    "max_cloud_cover": {"type": "number", "description": "Max cloud cover %"},
+                    "max_items": {"type": "integer", "description": "Max results"},
+                },
+                "required": [],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "create_rgb_composite",
+            "description": "Create RGB composite from Sentinel-2 data",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "zarr_url": {"type": "string", "description": "SR_10m Zarr URL"},
+                    "location_name": {"type": "string", "description": "Location for title"},
+                    "subset_size": {"type": "integer", "description": "Image size (default: 1000)"},
+                },
+                "required": ["zarr_url"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "calculate_ndvi",
+            "description": "Calculate NDVI vegetation index",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "zarr_url": {"type": "string", "description": "SR_10m Zarr URL"},
+                    "location_name": {"type": "string", "description": "Location for title"},
+                    "subset_size": {"type": "integer", "description": "Image size (default: 1000)"},
+                },
+                "required": ["zarr_url"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "search_imagery",
+            "description": "Search Sentinel-2 imagery by parameters",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "bbox": {"type": "array", "items": {"type": "number"}, "description": "Bounding box"},
+                    "start_date": {"type": "string", "description": "Start date YYYY-MM-DD"},
+                    "end_date": {"type": "string", "description": "End date YYYY-MM-DD"},
+                    "max_cloud_cover": {"type": "number", "description": "Max cloud cover %"},
+                    "max_items": {"type": "integer", "description": "Max results"},
+                },
+                "required": [],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_bbox_from_location",
+            "description": "Get bounding box for a location",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "place_name": {"type": "string", "description": "Location name"},
+                    "buffer_km": {"type": "number", "description": "Buffer distance in km"},
+                },
+                "required": ["place_name"],
+            },
+        },
+    },
+]
+
+
+class GeoMindAgent:
+    """Simplified GeoMind agent for satellite imagery analysis."""
+
+    def __init__(self, model: Optional[str] = None, api_key: Optional[str] = None):
+        self.api_key = api_key or OPENROUTER_API_KEY
+        self.model_name = model or OPENROUTER_MODEL
+        
+        if not self.api_key:
+            raise ValueError("OpenRouter API key required")
+            
+        print(f"GeoMind Agent initialized with {self.model_name}")
+        self.client = OpenAI(base_url=OPENROUTER_API_URL, api_key=self.api_key)
+        self.history = []
+
+    def _get_system_prompt(self) -> str:
+        """Short, focused system prompt."""
+        return f"""You are GeoMind, an AI assistant for satellite imagery analysis using Sentinel-2 data.
+
+Current date: {datetime.now().strftime('%Y-%m-%d')}
+
+KEY RULES:
+1. Use list_recent_imagery to find satellite data for locations
+2. Extract Zarr URLs from results: item['zarr_assets']['SR_10m']['href'] 
+3. Always include location_name parameter when creating images
+4. Use actual function response data in your answers (don't make up paths/stats)
+5. Let functions use default output paths (saves to outputs/ folder as .png)
+
+Be helpful and accurate - always use real data from function responses."""
+
+    def chat(self, message: str, verbose: bool = True) -> str:
+        """Send message to agent and get response."""
+        if verbose:
+            print(f"\nUser: {message}")
+            print("Processing...")
+
+        self.history.append({"role": "user", "content": message})
+        messages = [{"role": "system", "content": self._get_system_prompt()}] + self.history
+
+        for _ in range(10):  # Max 10 iterations
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                tools=TOOLS,
+                tool_choice="auto",
+                max_tokens=4096,
+            )
+
+            choice = response.choices[0]
+            assistant_message = choice.message
+
+            tool_calls = assistant_message.tool_calls
+            if tool_calls:
+                # Add assistant message with tool calls
+                messages.append({
+                    "role": "assistant",
+                    "content": assistant_message.content or "",
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {"name": tc.function.name, "arguments": tc.function.arguments},
+                        }
+                        for tc in tool_calls
+                    ],
+                })
+
+                # Execute tool calls
+                for tool_call in tool_calls:
+                    func_name = tool_call.function.name
+                    func_args = json.loads(tool_call.function.arguments)
+                    
+                    print(f"  Executing: {func_name}({func_args})")
+                    
+                    try:
+                        result = TOOL_FUNCTIONS[func_name](**func_args)
+                    except Exception as e:
+                        result = {"error": str(e)}
+
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": json.dumps(result, default=str),
+                    })
+            else:
+                # Final response
+                final_text = assistant_message.content or ""
+                self.history.append({"role": "assistant", "content": final_text})
+                
+                if verbose:
+                    print(f"\nGeoMind: {final_text}")
+                    
+                return final_text
+
+        return "Max iterations reached"
+
+    def reset(self):
+        """Reset chat history."""
+        self.history = []

geomind_ai-1.2.0/geomind/cli.py

@@ -0,0 +1,392 @@
+"""
+Command-line interface for GeoMind.
+"""
+
+import sys
+import os
+import argparse
+from pathlib import Path
+from typing import Optional
+import subprocess
+import platform
+import threading
+import time
+
+from .agent import GeoMindAgent
+
+
+# Config file path for storing API key
+CONFIG_DIR = Path.home() / ".geomind"
+CONFIG_FILE = CONFIG_DIR / "config"
+
+
+def get_saved_api_key() -> Optional[str]:
+    """Get API key saved on user's PC."""
+    if CONFIG_FILE.exists():
+        try:
+            return CONFIG_FILE.read_text().strip()
+        except Exception:
+            return None
+    return None
+
+
+def save_api_key(api_key: str) -> bool:
+    """Save API key to user's PC."""
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.write_text(api_key)
+        return True
+    except Exception:
+        return False
+
+
+def display_recent_images():
+    """Display recently created images if any exist."""
+    outputs_dir = Path("outputs")
+    if not outputs_dir.exists():
+        return
+    
+    # Get recent image files (created in last few seconds)
+    import time
+    recent_threshold = time.time() - 30  # 30 seconds ago
+    
+    recent_images = []
+    for ext in ['*.png', '*.jpg', '*.jpeg', '*.tiff']:
+        for img_file in outputs_dir.glob(ext):
+            if img_file.stat().st_mtime > recent_threshold:
+                recent_images.append(img_file)
+    
+    if recent_images:
+        print("\n" + "="*60)
+        print("Generated Images:")
+        for img in recent_images:
+            print(f"   • {img.name} ({img.stat().st_size // 1024}KB)")
+        
+        # Try to open the most recent image
+        if recent_images:
+            latest_image = max(recent_images, key=lambda x: x.stat().st_mtime)
+            open_image_viewer(latest_image)
+        print("="*60)
+
+
+def open_image_viewer(image_path: Path):
+    """Open image in default viewer."""
+    try:
+        system = platform.system()
+        if system == "Windows":
+            os.startfile(str(image_path))
+        elif system == "Darwin":  # macOS
+            subprocess.run(["open", str(image_path)], check=False)
+        else:  # Linux
+            subprocess.run(["xdg-open", str(image_path)], check=False)
+        print(f"   -> Opened {image_path.name} in default viewer")
+    except Exception:
+        print(f"   -> Saved to: {image_path}")
+
+
+def format_response_box(title: str, content: str, color_code: str = "\033[94m") -> str:
+    """Format response in an attractive box."""
+    RESET = "\033[0m"
+    lines = content.split('\n')
+    max_width = max(len(line) for line in lines) if lines else 0
+    max_width = max(max_width, len(title) + 4)
+    width = min(max_width + 4, 80)
+    
+    box = f"{color_code}"
+    box += "┌" + "─" * (width - 2) + "┐\n"
+    box += f"│ {title:<{width-4}} │\n"
+    box += "├" + "─" * (width - 2) + "┤\n"
+    
+    for line in lines:
+        if line.strip():
+            box += f"│ {line:<{width-4}} │\n"
+        else:
+            box += f"│{' ' * (width-2)}│\n"
+    
+    box += "└" + "─" * (width - 2) + "┘"
+    box += RESET
+    return box
+
+
+class ThinkingIndicator:
+    """Claude Code style thinking animation."""
+    
+    def __init__(self):
+        self.is_thinking = False
+        self.thread = None
+        self.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+        self.thinking_messages = [
+            "Thinking",
+            "Analyzing satellite data",
+            "Processing request",
+            "Searching imagery"
+        ]
+    
+    def start(self):
+        """Start the thinking animation."""
+        self.is_thinking = True
+        self.thread = threading.Thread(target=self._animate)
+        self.thread.daemon = True
+        self.thread.start()
+    
+    def stop(self):
+        """Stop the thinking animation."""
+        self.is_thinking = False
+        if self.thread:
+            self.thread.join(timeout=0.1)
+        # Clear the line
+        print("\r" + " " * 60 + "\r", end="", flush=True)
+    
+    def _animate(self):
+        """Run the thinking animation."""
+        frame_idx = 0
+        message_idx = 0
+        message_counter = 0
+        
+        # Colors like Claude Code
+        DIM = '\033[2m'
+        RESET = '\033[0m'
+        
+        while self.is_thinking:
+            spinner = self.frames[frame_idx % len(self.frames)]
+            
+            # Cycle through thinking messages every 30 frames (3 seconds)
+            if message_counter % 30 == 0:
+                message_idx = (message_idx + 1) % len(self.thinking_messages)
+            
+            message = self.thinking_messages[message_idx]
+            
+            # Show thinking with shimmer effect like Claude Code
+            print(f"\r{DIM}{spinner} {message}...{RESET}", end="", flush=True)
+            
+            time.sleep(0.1)
+            frame_idx += 1
+            message_counter += 1
+
+
+def main():
+    """Main CLI entry point for the geomind package."""
+    parser = argparse.ArgumentParser(
+        description="GeoMind - AI agent for geospatial analysis with Sentinel-2 imagery",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Interactive mode
+  geomind
+
+  # Single query
+  geomind --query "Find recent imagery of Paris"
+
+  # With custom model
+  geomind --model "anthropic/claude-3.5-sonnet"
+
+  # With API key
+  geomind --api-key "your-openrouter-api-key"
+
+  # Clear saved API key
+  geomind --clear-key
+
+Environment Variables:
+  OPENROUTER_API_KEY    Your OpenRouter API key
+  OPENROUTER_MODEL      Model to use (default: nvidia/nemotron-3-nano-30b-a3b:free)
+  OPENROUTER_API_URL    API endpoint (default: https://openrouter.ai/api/v1)
+        """,
+    )
+
+    parser.add_argument(
+        "--query",
+        "-q",
+        type=str,
+        help="Single query to run (if not provided, starts interactive mode)",
+    )
+    parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        help="Model name to use (e.g., 'anthropic/claude-3.5-sonnet')",
+    )
+    parser.add_argument(
+        "--api-key",
+        "-k",
+        type=str,
+        help="OpenRouter API key (or set OPENROUTER_API_KEY env variable)",
+    )
+    parser.add_argument(
+        "--version", "-v", action="store_true", help="Show version and exit"
+    )
+    parser.add_argument("--clear-key", action="store_true", help="Clear saved API key")
+
+    args = parser.parse_args()
+
+    if args.clear_key:
+        if CONFIG_FILE.exists():
+            CONFIG_FILE.unlink()
+            print("Saved API key cleared.")
+        else:
+            print("No saved API key found.")
+        sys.exit(0)
+
+    if args.version:
+        from . import __version__
+
+        print(f"GeoMind version {__version__}")
+        sys.exit(0)
+
+    # Start interactive or single-query mode
+    try:
+        if args.query:
+            # Single query mode - check API key in order: argument > env > saved file
+            from .config import OPENROUTER_API_KEY
+            
+            api_key = args.api_key or OPENROUTER_API_KEY or get_saved_api_key()
+            if not api_key:
+                print("Error: No API key found. Run 'geomind' first to set up.")
+                sys.exit(1)
+            agent = GeoMindAgent(model=args.model, api_key=api_key)
+            agent.chat(args.query)
+        else:
+            # Interactive mode
+            run_interactive(model=args.model, api_key=args.api_key)
+    except ValueError as e:
+        print(f"\nError: {e}")
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\n\nGoodbye!")
+        sys.exit(0)
+    except Exception as e:
+        print(f"\nUnexpected error: {e}")
+        sys.exit(1)
+
+
+def print_banner():
+    from . import __version__
+    
+    # ANSI color codes
+    BOLD = '\033[1m'
+    DIM = '\033[2m'
+    RESET = '\033[0m'
+    
+    banner = f"""
+┌──────────────────────────────────────────────────────────────────────┐
+│ {BOLD}>_ GeoMind{RESET} (v{__version__})                                                  │
+│                                                                      │
+│ model:     nvidia/nemotron-3-nano-30b-a3b:free                       │
+│ docs:      https://harshshinde0.github.io/GeoMind                    │
+│ authors:   Harsh Shinde, Rajat Shinde                                │
+│ official:  https://harshshinde0.github.io/GeoMind                    │
+│                                                                      │
+│ Type "?" for help, "quit" to exit.                                   │
+└──────────────────────────────────────────────────────────────────────┘
+"""
+    print(banner)
+    print()
+
+
+def print_help():
+    """Print interactive session help."""
+    help_text = """
+Interactive Commands:
+  help, ?          Show this help
+  reset            Reset conversation
+  exit, quit, q    Exit GeoMind
+
+Query Examples:
+  > Find recent Sentinel-2 imagery of Paris
+  > Show me NDVI data for the Amazon rainforest  
+  > Search for images with less than 10% cloud cover in London
+  > Get satellite data for coordinates 40.7128, -74.0060
+
+For CLI options, run: geomind --help
+    """
+    print(help_text)
+
+
+def run_interactive(model: Optional[str] = None, api_key: Optional[str] = None):
+    """Run interactive CLI mode."""
+    from . import __version__
+
+    print_banner()
+
+    # Check for API key in order: argument > env > saved file
+    from .config import OPENROUTER_API_KEY
+
+    # Priority: command line arg > env variable > saved file
+    if api_key:
+        # Use provided argument
+        pass
+    elif OPENROUTER_API_KEY:
+        api_key = OPENROUTER_API_KEY
+    else:
+        api_key = get_saved_api_key()
+
+    if not api_key:
+        print("\nOpenRouter API key required (FREE)")
+        print("   Get yours at: https://openrouter.ai/settings/keys\n")
+        api_key = input("   Enter your API key: ").strip()
+
+        if not api_key:
+            print("\nNo API key provided. Exiting.")
+            return
+
+        # Save the key for future use
+        if save_api_key(api_key):
+            print("   API key saved! You won't need to enter it again.\n")
+        else:
+            print("   Warning: Could not save API key. You'll need to enter it next time.\n")
+
+    agent = GeoMindAgent(model=model, api_key=api_key)
+
+    # Claude Code style color scheme
+    CYAN = '\033[96m'
+    DIM = '\033[2m' 
+    BOLD = '\033[1m'
+    RESET = '\033[0m'
+
+    while True:
+        try:
+            # Simple prompt like Claude Code
+            user_input = input(f"\n{CYAN}>{RESET} ").strip()
+
+            if not user_input:
+                continue
+
+            if user_input.lower() in ["quit", "exit", "q"]:
+                print(f"\n{DIM}Goodbye!{RESET}")
+                break
+
+            if user_input.lower() == "reset":
+                agent.reset()
+                print(f"{DIM}Started new conversation{RESET}")
+                continue
+
+            if user_input.lower() in ["help", "?"]:
+                print_help()
+                continue
+
+            # Start thinking animation
+            thinking = ThinkingIndicator()
+            thinking.start()
+            
+            try:
+                # Get response from agent
+                response = agent.chat(user_input, verbose=False)
+                
+                # Stop thinking animation
+                thinking.stop()
+                
+                # Display response cleanly like Claude Code
+                print(f"\n{response}")
+                
+            except Exception as chat_error:
+                thinking.stop()
+                raise chat_error
+
+        except KeyboardInterrupt:
+            print(f"\n\n{DIM}Goodbye!{RESET}")
+            break
+        except Exception as e:
+            print(f"\n{DIM}Error: {e}{RESET}")
+
+
+if __name__ == "__main__":
+    main()

{geomind_ai-1.1.0 → geomind_ai-1.2.0}/geomind/config.py

@@ -37,9 +37,9 @@ REFLECTANCE_OFFSET = -0.1
 RGB_BANDS = {"red": "b04", "green": "b03", "blue": "b02"}
 
 # Default search parameters
-DEFAULT_MAX_CLOUD_COVER = 20  # percent
-DEFAULT_BUFFER_KM = 10  # km buffer around point for bbox
-DEFAULT_MAX_ITEMS = 10
+DEFAULT_MAX_CLOUD_COVER = 50  # percent (increased for better results)
+DEFAULT_BUFFER_KM = 15  # km buffer around point for bbox (increased coverage)
+DEFAULT_MAX_ITEMS = 20  # increased to find more options
 
 # Output directory for saved images
 OUTPUT_DIR = Path("outputs")