Integrate OpenRouter GLM model with RAG tool calling

- Replace Google Gemini with OpenRouter GLM-4.5-air model
- Add intelligent tool calling for RAG pipeline access
- Implement new /chat endpoint with multi-turn conversation support
- Remove Google API key dependency
- Add comprehensive .gitignore for Python projects
- Maintain backward compatibility with existing /answer endpoint

Features:
- GLM model automatically decides when to use RAG vs general chat
- Tool calling architecture for extensible functionality
- Background dataset loading for faster startup
- Support for developer-portfolio and other datasets

.gitignore

@@ -0,0 +1,163 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Model files
+*.pkl
+*.joblib
+*.bin
+*.onnx
+
+# Data files
+data/
+datasets/
+*.csv
+*.json
+*.jsonl
+*.parquet
+
+# Logs
+logs/
+*.log
+
+# Temporary files
+tmp/
+temp/
+*.tmp

app/config.py

@@ -7,7 +7,7 @@ class DatasetConfig:
     name: str
     split: str = "train"
     content_field: str = "content"
-    fields: Dict[str, str] = None  # Dictionary of field mappings
+    fields: Optional[Dict[str, str]] = None  # Dictionary of field mappings
     prompt_template: Optional[str] = None
 
 # Default configurations for different datasets
@@ -164,8 +164,7 @@ DATASET_CONFIGS = {
     ),
 }
 
-# Default configuration for embedding and LLM models
+# Default configuration for embedding model
 MODEL_CONFIG = {
     "embedding_model": "sentence-transformers/all-MiniLM-L6-v2",
-    "llm_model": "gemini-2.0-flash-exp",
 }

app/main.py

@@ -4,6 +4,10 @@ import os
 import logging
 import sys
 from .config import DATASET_CONFIGS
+from openai import OpenAI
+from openai.types.chat import ChatCompletionMessageParam
+import json
+
 # Lazy imports to avoid blocking startup
 # from .pipeline import RAGPipeline  # Will import when needed
 # import umap  # Will import when needed for visualization
@@ -13,7 +17,6 @@ from .config import DATASET_CONFIGS
 # import numpy as np  # Will import when needed for visualization
 # from sklearn.preprocessing import normalize  # Will import when needed for visualization
 # import pandas as pd  # Will import when needed for visualization
-import json
 
 # Configure logging
 logging.basicConfig(
@@ -27,6 +30,15 @@ logger = logging.getLogger(__name__)
 
 app = FastAPI(title="RAG Pipeline API", description="Multi-dataset RAG API", version="1.0.0")
 
+# Initialize OpenRouter client
+openrouter_client = OpenAI(
+    base_url="https://openrouter.ai/api/v1",
+    api_key="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"
+)
+
+# Model configuration
+MODEL_NAME = "z-ai/glm-4.5-air:free"
+
 # Initialize pipelines for all datasets
 pipelines = {}
 google_api_key = os.getenv("GOOGLE_API_KEY")
@@ -36,6 +48,59 @@ logger.info(f"Port from env: {os.getenv('PORT', 'Not set - will use 8000')}")
 logger.info(f"Google API Key present: {'Yes' if google_api_key else 'No'}")
 logger.info(f"Available datasets: {list(DATASET_CONFIGS.keys())}")
 
+# Define tools for the GLM model
+def rag_qa(question: str, dataset: str = "developer-portfolio") -> str:
+    """
+    Get answers from the RAG pipeline for specific questions about the dataset.
+    
+    Args:
+        question: The question to answer using the RAG pipeline
+        dataset: The dataset to search in (default: developer-portfolio)
+    
+    Returns:
+        Answer from the RAG pipeline
+    """
+    try:
+        # Check if pipelines are loaded
+        if not pipelines:
+            return "RAG Pipeline is running but datasets are still loading in the background. Please try again in a moment."
+        
+        # Select the appropriate pipeline based on dataset
+        if dataset not in pipelines:
+            return f"Dataset '{dataset}' not available. Available datasets: {list(pipelines.keys())}"
+        
+        selected_pipeline = pipelines[dataset]
+        answer = selected_pipeline.answer_question(question)
+        return answer
+    except Exception as e:
+        return f"Error accessing RAG pipeline: {str(e)}"
+
+# Tool definitions for GLM
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "rag_qa",
+            "description": "Get answers from the RAG pipeline for specific questions about datasets",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "question": {
+                        "type": "string",
+                        "description": "The question to answer using the RAG pipeline"
+                    },
+                    "dataset": {
+                        "type": "string",
+                        "description": "The dataset to search in (default: developer-portfolio)",
+                        "default": "developer-portfolio"
+                    }
+                },
+                "required": ["question"]
+            }
+        }
+    }
+]
+
 # Don't load datasets during startup - do it asynchronously after server starts
 logger.info("RAG Pipeline API is ready to serve requests - datasets will load in background")
 
@@ -47,6 +112,118 @@ class Question(BaseModel):
     text: str
     dataset: str = "developer-portfolio"  # Default dataset
 
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ChatRequest(BaseModel):
+    messages: list[ChatMessage]
+    dataset: str = "developer-portfolio"  # Default dataset
+
+@app.post("/chat")
+async def chat_with_ai(request: ChatRequest):
+    """
+    Chat with the AI assistant. The AI will use the RAG pipeline when needed to answer questions about the datasets.
+    """
+    try:
+        # Convert messages to OpenAI format with proper typing
+        messages: list[ChatCompletionMessageParam] = [
+            {"role": msg.role, "content": msg.content}  # type: ignore
+            for msg in request.messages
+        ]
+        
+        # Add system message to guide the AI
+        system_message: ChatCompletionMessageParam = {
+            "role": "system",
+            "content": "You are a helpful AI assistant. You have access to a RAG (Retrieval-Augmented Generation) pipeline that can answer questions about specific datasets. Use the rag_qa tool when users ask questions that would benefit from searching the dataset knowledge. For general conversation, respond normally. The available datasets are primarily focused on developer portfolio information, but can include other topics depending on what's loaded."
+        }
+        
+        # Insert system message at the beginning
+        messages.insert(0, system_message)
+        
+        # Make the API call with tools
+        response = openrouter_client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages,
+            tools=TOOLS,  # type: ignore
+            tool_choice="auto"
+        )
+        
+        message = response.choices[0].message
+        finish_reason = response.choices[0].finish_reason
+        
+        # Handle tool calls
+        if finish_reason == "tool_calls" and hasattr(message, 'tool_calls') and message.tool_calls:
+            tool_results = []
+            
+            # Execute tool calls
+            for tool_call in message.tool_calls:
+                if tool_call.function.name == "rag_qa":
+                    # Parse arguments
+                    args = json.loads(tool_call.function.arguments)
+                    question = args.get("question")
+                    dataset = args.get("dataset", request.dataset)
+                    
+                    # Call the rag_qa function
+                    result = rag_qa(question, dataset)
+                    tool_results.append({
+                        "tool_call_id": tool_call.id,
+                        "result": result
+                    })
+            
+            # Add tool results to conversation and get final response
+            assistant_message: ChatCompletionMessageParam = {
+                "role": "assistant",
+                "content": message.content or "",
+                "tool_calls": [
+                    {
+                        "id": tc.id,
+                        "type": tc.type,
+                        "function": {
+                            "name": tc.function.name,
+                            "arguments": tc.function.arguments
+                        }
+                    }
+                    for tc in message.tool_calls
+                ]
+            }
+            messages.append(assistant_message)
+            
+            for tool_result in tool_results:
+                tool_message: ChatCompletionMessageParam = {
+                    "role": "tool",
+                    "tool_call_id": tool_result["tool_call_id"],
+                    "content": tool_result["result"]
+                }
+                messages.append(tool_message)
+            
+            # Get final response
+            final_response = openrouter_client.chat.completions.create(
+                model=MODEL_NAME,
+                messages=messages
+            )
+            
+            return {
+                "response": final_response.choices[0].message.content,
+                "tool_calls": [
+                    {
+                        "name": tc.function.name,
+                        "arguments": tc.function.arguments,
+                        "result": next(tr["result"] for tr in tool_results if tr["tool_call_id"] == tc.id)
+                    }
+                    for tc in message.tool_calls
+                ] if message.tool_calls else None
+            }
+        else:
+            # Direct response without tool calls
+            return {
+                "response": message.content,
+                "tool_calls": None
+            }
+            
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.post("/answer")
 async def get_answer(question: Question):
     try:
@@ -86,24 +263,18 @@ async def list_questions(dataset: str = "developer-portfolio"):
 async def load_datasets_background():
     """Load datasets in background after server starts"""
     global pipelines
-    if google_api_key:
-        # Import RAGPipeline only when needed
-        from .pipeline import RAGPipeline
-        # Only load developer-portfolio to save memory
-        dataset_name = "developer-portfolio"
-        try:
-            logger.info(f"Loading dataset: {dataset_name}")
-            pipeline = RAGPipeline.from_preset(
-                google_api_key=google_api_key,
-                preset_name=dataset_name
-            )
-            pipelines[dataset_name] = pipeline
-            logger.info(f"Successfully loaded {dataset_name}")
-        except Exception as e:
-            logger.error(f"Failed to load {dataset_name}: {e}")
-        logger.info(f"Background loading complete - {len(pipelines)} datasets loaded")
-    else:
-        logger.warning("No Google API key provided - running in demo mode without datasets")
+    # Import RAGPipeline only when needed
+    from .pipeline import RAGPipeline
+    # Only load developer-portfolio to save memory
+    dataset_name = "developer-portfolio"
+    try:
+        logger.info(f"Loading dataset: {dataset_name}")
+        pipeline = RAGPipeline.from_preset(preset_name=dataset_name)
+        pipelines[dataset_name] = pipeline
+        logger.info(f"Successfully loaded {dataset_name}")
+    except Exception as e:
+        logger.error(f"Failed to load {dataset_name}: {e}")
+    logger.info(f"Background loading complete - {len(pipelines)} datasets loaded")
 
 @app.on_event("startup")
 async def startup_event():

app/pipeline.py

@@ -2,8 +2,7 @@ from haystack import Document, Pipeline
 from haystack.document_stores.in_memory import InMemoryDocumentStore
 from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder
 from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
-from haystack.components.builders import ChatPromptBuilder
-from haystack_integrations.components.generators.google_ai import GoogleAIGeminiChatGenerator
+from haystack.components.builders import PromptBuilder
 from datasets import load_dataset
 from haystack.dataclasses import ChatMessage
 from typing import Optional, List, Union, Dict
@@ -12,21 +11,17 @@ from .config import DatasetConfig, DATASET_CONFIGS, MODEL_CONFIG
 class RAGPipeline:
     def __init__(
         self,
-        google_api_key: str,
         dataset_config: Union[str, DatasetConfig],
         documents: Optional[List[Union[str, Document]]] = None,
-        embedding_model: Optional[str] = None,
-        llm_model: Optional[str] = None
+        embedding_model: Optional[str] = None
     ):
         """
         Initialize the RAG Pipeline.
         
         Args:
-            google_api_key: API key for Google AI services
             dataset_config: Either a string key from DATASET_CONFIGS or a DatasetConfig object
             documents: Optional list of documents to use instead of loading from a dataset
             embedding_model: Optional override for embedding model
-            llm_model: Optional override for LLM model
         """
         # Load configuration
         if isinstance(dataset_config, str):
@@ -74,19 +69,22 @@ class RAGPipeline:
         )
         self.retriever = InMemoryEmbeddingRetriever(self.document_store)
         
-        # Warm up the document embedder
+        # Warm up the embedders
         self.doc_embedder.warm_up()
+        self.text_embedder.warm_up()
         
         # Initialize prompt template
-        template = [
-            ChatMessage.from_user(self.config.prompt_template)
-        ]
-        self.prompt_builder = ChatPromptBuilder(template=template)
-
-        # Initialize the generator
-        self.generator = GoogleAIGeminiChatGenerator(
-            model=llm_model or MODEL_CONFIG["llm_model"]
-        )
+        self.prompt_builder = PromptBuilder(template=self.config.prompt_template or """
+        Given the following context, please answer the question.
+        
+        Context:
+        {% for document in documents %}
+            {{ document.content }}
+        {% endfor %}
+        
+        Question: {{question}}
+        Answer:
+        """)
         
         # Index documents
         self._index_documents(self.documents)
@@ -95,15 +93,14 @@ class RAGPipeline:
         self.pipeline = self._build_pipeline()
 
     @classmethod
-    def from_preset(cls, google_api_key: str, preset_name: str):
+    def from_preset(cls, preset_name: str):
         """
         Create a pipeline from a preset configuration.
         
         Args:
-            google_api_key: API key for Google AI services
             preset_name: Name of the preset configuration to use
         """
-        return cls(google_api_key=google_api_key, dataset_config=preset_name)
+        return cls(dataset_config=preset_name)
 
     def _index_documents(self, documents):
         # Embed and index documents
@@ -115,19 +112,24 @@ class RAGPipeline:
         pipeline.add_component("text_embedder", self.text_embedder)
         pipeline.add_component("retriever", self.retriever)
         pipeline.add_component("prompt_builder", self.prompt_builder)
-        pipeline.add_component("llm", self.generator)
         
         # Connect components
         pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
         pipeline.connect("retriever", "prompt_builder")
-        pipeline.connect("prompt_builder.prompt", "llm.messages")
         
         return pipeline
     
     def answer_question(self, question: str) -> str:
         """Run the RAG pipeline to answer a question"""
-        result = self.pipeline.run({
-            "text_embedder": {"text": question},
-            "prompt_builder": {"question": question}
-        })
-        return result["llm"]["replies"][0].text 
+        # First, embed the question and retrieve relevant documents
+        embedded_question = self.text_embedder.run(text=question)
+        retrieved_docs = self.retriever.run(query_embedding=embedded_question["embedding"])
+        
+        # Then, build the prompt with retrieved documents
+        prompt_result = self.prompt_builder.run(
+            question=question, 
+            documents=retrieved_docs["documents"]
+        )
+        
+        # Return the formatted prompt (this will be processed by the main AI)
+        return prompt_result["prompt"]

test_openrouter_connection.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+"""
+Test script for OpenRouter API connection with z-ai/glm-4.5-air:free model.
+Tests basic functionality and tool calling capabilities.
+"""
+
+import json
+import os
+import sys
+from openai import OpenAI
+
+# Model configuration
+MODEL_NAME = "z-ai/glm-4.5-air:free"
+
+def test_basic_connection():
+    """Test basic API connection with a simple prompt."""
+    print("=" * 60)
+    print("Testing Basic OpenRouter Connection")
+    print("=" * 60)
+    
+    try:
+        # Initialize OpenRouter client with the same configuration as app.py
+        client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key="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"
+        )
+        
+        # Test with a simple prompt
+        messages = [
+            {"role": "user", "content": "Hello! Please respond with a simple greeting and your name."}
+        ]
+        
+        print("Sending test request to OpenRouter API...")
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages
+        )
+        
+        # Extract and display the response
+        content = response.choices[0].message.content
+        print(f"✅ SUCCESS: API connection works!")
+        print(f"Model: {response.model}")
+        print(f"Response: {content}")
+        print(f"Usage: {response.usage}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ FAILED: Basic connection test failed")
+        print(f"Error: {str(e)}")
+        return False
+
+def test_tool_calling():
+    """Test tool calling functionality."""
+    print("\n" + "=" * 60)
+    print("Testing Tool Calling Functionality")
+    print("=" * 60)
+    
+    try:
+        # Initialize OpenRouter client
+        client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key="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"
+        )
+        
+        # Define test tools (similar to app.py)
+        tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_weather",
+                    "description": "Get current weather information",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "location": {
+                                "type": "string",
+                                "description": "The city name for weather information"
+                            }
+                        },
+                        "required": ["location"]
+                    }
+                }
+            }
+        ]
+        
+        # Test prompt that should trigger tool calling
+        messages = [
+            {"role": "user", "content": "What's the weather like in New York?"}
+        ]
+        
+        print("Sending test request with tool calling capability...")
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages,
+            tools=tools
+        )
+        
+        # Analyze the response
+        finish_reason = response.choices[0].finish_reason
+        message = response.choices[0].message
+        
+        print(f"✅ SUCCESS: Tool calling test completed!")
+        print(f"Model: {response.model}")
+        print(f"Finish Reason: {finish_reason}")
+        
+        if finish_reason == "tool_calls":
+            print("🔧 Tool calls detected:")
+            if hasattr(message, 'tool_calls') and message.tool_calls:
+                for tool_call in message.tool_calls:
+                    print(f"  - Tool: {tool_call.function.name}")
+                    print(f"  - Arguments: {tool_call.function.arguments}")
+            else:
+                print("  - No tool calls found in response")
+        else:
+            print(f"  - Response content: {message.content}")
+        
+        print(f"Usage: {response.usage}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ FAILED: Tool calling test failed")
+        print(f"Error: {str(e)}")
+        return False
+
+def test_error_handling():
+    """Test error handling with invalid requests."""
+    print("\n" + "=" * 60)
+    print("Testing Error Handling")
+    print("=" * 60)
+    
+    try:
+        # Initialize OpenRouter client
+        client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key="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"
+        )
+        
+        # Test with empty messages
+        print("Testing empty messages...")
+        try:
+            response = client.chat.completions.create(
+                model="z-ai/glm-4.5-air:free",
+                messages=[]
+            )
+            print("⚠️  Unexpected: Empty messages request succeeded")
+        except Exception as e:
+            print(f"✅ Expected error caught: {str(e)}")
+        
+        # Test with invalid model
+        print("Testing invalid model...")
+        try:
+            response = client.chat.completions.create(
+                model="invalid-model-name",
+                messages=[{"role": "user", "content": "Hello"}]
+            )
+            print("⚠️  Unexpected: Invalid model request succeeded")
+        except Exception as e:
+            print(f"✅ Expected error caught: {str(e)}")
+        
+        print("✅ SUCCESS: Error handling tests completed")
+        return True
+        
+    except Exception as e:
+        print(f"❌ FAILED: Error handling test failed")
+        print(f"Error: {str(e)}")
+        return False
+
+def test_conversation_flow():
+    """Test a multi-turn conversation."""
+    print("\n" + "=" * 60)
+    print("Testing Multi-turn Conversation")
+    print("=" * 60)
+    
+    try:
+        # Initialize OpenRouter client
+        client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key="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"
+        )
+        
+        # Simulate a conversation
+        messages = [
+            {"role": "user", "content": "Hello! Can you help me understand what AI is?"}
+        ]
+        
+        print("Starting conversation flow...")
+        
+        # First turn
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages
+        )
+        
+        content = response.choices[0].message.content
+        print(f"Assistant: {content}")
+        
+# Second turn
+        messages.append({"role": "assistant", "content": content})
+        messages.append({"role": "user", "content": "Can you give me a simple example?"})
+        
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages
+        )
+        
+        content = response.choices[0].message.content
+        print(f"Assistant: {content}")
+        
+        print("✅ SUCCESS: Multi-turn conversation completed")
+        return True
+        
+    except Exception as e:
+        print(f"❌ FAILED: Conversation flow test failed")
+        print(f"Error: {str(e)}")
+        return False
+
+def main():
+    """Main test function."""
+    print("🚀 Starting OpenRouter API Connection Tests")
+    print(f"Model: {MODEL_NAME}")
+    print(f"API Base URL: https://openrouter.ai/api/v1")
+    
+    # Run all tests
+    tests = [
+        ("Basic Connection", test_basic_connection),
+        ("Tool Calling", test_tool_calling),
+        ("Error Handling", test_error_handling),
+        ("Conversation Flow", test_conversation_flow)
+    ]
+    
+    results = []
+    for test_name, test_func in tests:
+        try:
+            result = test_func()
+            results.append((test_name, result))
+        except Exception as e:
+            print(f"❌ CRITICAL ERROR in {test_name}: {str(e)}")
+            results.append((test_name, False))
+    
+    # Summary
+    print("\n" + "=" * 60)
+    print("TEST SUMMARY")
+    print("=" * 60)
+    
+    passed = 0
+    total = len(results)
+    
+    for test_name, result in results:
+        status = "✅ PASSED" if result else "❌ FAILED"
+        print(f"{status}: {test_name}")
+        if result:
+            passed += 1
+    
+    print(f"\nOverall: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All tests passed! OpenRouter integration is working correctly.")
+        return 0
+    else:
+        print("⚠️  Some tests failed. Please check the configuration and API credentials.")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())