feat: support qwen and openrouters

app.py

@@ -8,11 +8,8 @@ from pathlib import Path
 
 from geo_bot import GeoBot, AGENT_PROMPT_TEMPLATE
 from benchmark import MapGuesserBenchmark
-from config import MODELS_CONFIG, get_data_paths, SUCCESS_THRESHOLD_KM
-from langchain_openai import ChatOpenAI
-from langchain_anthropic import ChatAnthropic
-from langchain_google_genai import ChatGoogleGenerativeAI
-from hf_chat import HuggingFaceChat
+from config import MODELS_CONFIG, get_data_paths, SUCCESS_THRESHOLD_KM, get_model_class
+
 
 # Simple API key setup
 if "OPENAI_API_KEY" in st.secrets:
@@ -38,19 +35,6 @@ def get_available_datasets():
     return datasets if datasets else ["default"]
 
 
-def get_model_class(class_name):
-    if class_name == "ChatOpenAI":
-        return ChatOpenAI
-    elif class_name == "ChatAnthropic":
-        return ChatAnthropic
-    elif class_name == "ChatGoogleGenerativeAI":
-        return ChatGoogleGenerativeAI
-    elif class_name == "HuggingFaceChat":
-        return HuggingFaceChat
-    else:
-        raise ValueError(f"Unknown model class: {class_name}")
-
-
 # UI Setup
 st.set_page_config(page_title="🧠 Omniscient - AI Geographic Analysis", layout="wide")
 st.title("🧠 Omniscient")

benchmark.py

@@ -9,7 +9,7 @@ from pathlib import Path
 import math
 
 from geo_bot import GeoBot
-from config import get_data_paths, MODELS_CONFIG, SUCCESS_THRESHOLD_KM
+from config import get_data_paths, MODELS_CONFIG, SUCCESS_THRESHOLD_KM, get_model_class
 
 
 class MapGuesserBenchmark:
@@ -29,25 +29,6 @@ class MapGuesserBenchmark:
         except Exception:
             return []
 
-    def get_model_class(self, model_name: str):
-        config = MODELS_CONFIG.get(model_name)
-        if not config:
-            raise ValueError(f"Unknown model: {model_name}")
-        class_name, model_class_name = config["class"], config["model_name"]
-        if class_name == "ChatOpenAI":
-            from langchain_openai import ChatOpenAI
-
-            return ChatOpenAI, model_class_name
-        if class_name == "ChatAnthropic":
-            from langchain_anthropic import ChatAnthropic
-
-            return ChatAnthropic, model_class_name
-        if class_name == "ChatGoogleGenerativeAI":
-            from langchain_google_genai import ChatGoogleGenerativeAI
-
-            return ChatGoogleGenerativeAI, model_class_name
-        raise ValueError(f"Unknown model class: {class_name}")
-
     def calculate_distance(
         self, true_coords: Dict, predicted_coords: Optional[Tuple[float, float]]
     ) -> Optional[float]:
@@ -99,7 +80,9 @@ class MapGuesserBenchmark:
         all_results = []
         for model_name in models_to_test:
             print(f"\n🤖 Testing model: {model_name}")
-            model_class, model_class_name = self.get_model_class(model_name)
+            model_config = MODELS_CONFIG[model_name]
+            model_class = get_model_class(model_config["class"])
+            model_class_name = model_config["model_name"]
 
             try:
                 with GeoBot(

config.py

@@ -1,5 +1,10 @@
 # Configuration file for MapCrunch benchmark
 
+from pydantic import SecretStr, Field
+from typing import Optional
+import os
+
+
 SUCCESS_THRESHOLD_KM = 100
 
 # MapCrunch settings
@@ -38,10 +43,15 @@ MODELS_CONFIG = {
         "model_name": "gpt-4o-mini",
         "description": "OpenAI GPT-4o Mini",
     },
-    "claude-3.5-sonnet": {
+    "claude-3-7-sonnet": {
+        "class": "ChatAnthropic",
+        "model_name": "claude-3-7-sonnet-20250219",
+        "description": "Anthropic Claude 3.7 Sonnet",
+    },
+    "claude-4-sonnet": {
         "class": "ChatAnthropic",
-        "model_name": "claude-3-5-sonnet-20240620",
-        "description": "Anthropic Claude 3.5 Sonnet",
+        "model_name": "claude-4-sonnet-20250514",
+        "description": "Anthropic Claude 4 Sonnet",
     },
     "gemini-1.5-pro": {
         "class": "ChatGoogleGenerativeAI",
@@ -58,19 +68,76 @@ MODELS_CONFIG = {
         "model_name": "gemini-2.5-pro-preview-06-05",
         "description": "Google Gemini 2.5 Pro",
     },
-    "qwen2-vl-7b": {
-        "class": "HuggingFaceChat",
-        "model_name": "Qwen/Qwen2-VL-7B-Instruct",
-        "description": "Qwen2-VL 7B (older but API supported)",
+    "qwen-vl-max": {
+        "class": "OpenRouter",
+        "model_name": "qwen/qwen-vl-max",
+        "description": "Qwen VL Max - OpenRouter (Best Performance)",
     },
-    "qwen2-vl-2b": {
-        "class": "HuggingFaceChat",
-        "model_name": "Qwen/Qwen2-VL-2B-Instruct",
-        "description": "Qwen2-VL 2B (faster, API supported)",
+    "qwen2.5-vl-32b-free": {
+        "class": "OpenRouter",
+        "model_name": "qwen/qwen2.5-vl-32b-instruct:free",
+        "description": "Qwen2.5 VL 32B - OpenRouter (FREE!)",
+    },
+    "qwen2.5-vl-7b": {
+        "class": "OpenRouter",
+        "model_name": "qwen/qwen2.5-vl-7b-instruct",
+        "description": "Qwen2.5 VL 7B - OpenRouter",
+    },
+    "qwen2.5-vl-3b": {
+        "class": "OpenRouter",
+        "model_name": "qwen/qwen2.5-vl-3b-instruct",
+        "description": "Qwen2.5 VL 3B - OpenRouter (Fastest)",
     },
 }
 
 
+def get_model_class(class_name):
+    """Get actual model class from string name"""
+    if class_name == "ChatOpenAI":
+        from langchain_openai import ChatOpenAI
+
+        return ChatOpenAI
+    elif class_name == "ChatAnthropic":
+        from langchain_anthropic import ChatAnthropic
+
+        return ChatAnthropic
+    elif class_name == "ChatGoogleGenerativeAI":
+        from langchain_google_genai import ChatGoogleGenerativeAI
+
+        return ChatGoogleGenerativeAI
+    elif class_name == "HuggingFaceChat":
+        from hf_chat import HuggingFaceChat
+
+        return HuggingFaceChat
+    elif class_name == "OpenRouter":
+        from langchain_openai import ChatOpenAI
+        from langchain_core.utils.utils import secret_from_env
+
+        # LangChain does not support OpenRouter directly, so we need to create a custom class
+        # See https://github.com/langchain-ai/langchain/discussions/27964.
+        class ChatOpenRouter(ChatOpenAI):
+            openai_api_key: Optional[SecretStr] = Field(
+                alias="api_key",
+                default_factory=secret_from_env("OPENROUTER_API_KEY", default=None),
+            )
+
+            @property
+            def lc_secrets(self) -> dict[str, str]:
+                return {"openai_api_key": "OPENROUTER_API_KEY"}
+
+            def __init__(self, openai_api_key: Optional[str] = None, **kwargs):
+                openai_api_key = openai_api_key or os.environ.get("OPENROUTER_API_KEY")
+                super().__init__(
+                    base_url="https://openrouter.ai/api/v1",
+                    api_key=SecretStr(openai_api_key) if openai_api_key else None,
+                    **kwargs,
+                )
+
+        return ChatOpenRouter
+    else:
+        raise ValueError(f"Unknown model class: {class_name}")
+
+
 # Data paths - now supports named datasets
 def get_data_paths(dataset_name: str = "default"):
     """Get data paths for a specific dataset"""

main.py

@@ -10,7 +10,7 @@ from langchain_google_genai import ChatGoogleGenerativeAI
 from geo_bot import GeoBot
 from benchmark import MapGuesserBenchmark
 from data_collector import DataCollector
-from config import MODELS_CONFIG, get_data_paths, SUCCESS_THRESHOLD_KM
+from config import MODELS_CONFIG, get_data_paths, SUCCESS_THRESHOLD_KM, get_model_class
 
 
 def agent_mode(
@@ -48,7 +48,7 @@ def agent_mode(
     print(f"Will run on {len(test_samples)} samples from dataset '{dataset_name}'.")
 
     config = MODELS_CONFIG.get(model_name)
-    model_class = globals()[config["class"]]
+    model_class = get_model_class(config["class"])
     model_instance_name = config["model_name"]
 
     benchmark_helper = MapGuesserBenchmark(dataset_name=dataset_name, headless=True)