diff --git a/Products/zms/_confmanager.py b/Products/zms/_confmanager.py index 9305b1c6a..8c20274ff 100644 --- a/Products/zms/_confmanager.py +++ b/Products/zms/_confmanager.py @@ -551,6 +551,13 @@ def getConfPropertiesDefaults(self): {'key':'ZMSIndexZCatalog.ObjectImported.resync','title':'Resync ZMSIndex on content import','desc':'Please be aware that activating implicit ZMSIndex-resync on content import can block bigger sites for a while','datatype':'boolean','default':0}, {'key':'ZReferableItem.validateLinkObj','title':'Auto-correct link-attributes on save','desc':'Ensure valid link-attributes by parsing and using ZMSIndex for refreshing target urls on save event','datatype':'boolean','default':1}, {'key':'ZReferableItem.validateInlineLinkObj','title':'Auto-correct inline-links on save','desc':'Ensure valid inline-links by text-parsing and using ZMSIndex for refreshing target urls on save event','datatype':'boolean','default':1}, + {'key':'llm.provider','title':'LLM Provider','desc':'LLM provider type: openai, ollama, or rag','datatype':'string','options':['openai', 'ollama', 'rag'],'default':'openai'}, + {'key':'llm.api.key','title':'LLM API Key','desc':'API key for OpenAI (if provider is openai)','datatype':'string','default':''}, + {'key':'llm.api.model','title':'LLM Model','desc':'Model name for the LLM provider','datatype':'string','options':['gpt-3.5-turbo', 'gpt-4', 'gpt-4o-mini', 'llama2', 'mistral', 'codellama'],'default':'gpt-4o-mini'}, + {'key':'llm.api.endpoint','title':'LLM API Endpoint','desc':'Custom API endpoint URL','datatype':'string','default':'https://api.openai.com/v1/chat/completions'}, + {'key':'llm.ollama.host','title':'Ollama Host','desc':'Ollama server URL (for ollama and rag providers)','datatype':'string','default':'http://localhost:11434'}, + {'key':'llm.qdrant.host','title':'Qdrant Host','desc':'Qdrant server URL (for rag provider)','datatype':'string','default':'http://localhost:6333'}, + {'key':'llm.qdrant.collection','title':'Qdrant Collection','desc':'Qdrant collection name (for rag provider)','datatype':'string','default':'zms_docs'} ] """ diff --git a/Products/zms/llmapi.py b/Products/zms/llmapi.py new file mode 100644 index 000000000..e078eabd7 --- /dev/null +++ b/Products/zms/llmapi.py @@ -0,0 +1,668 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +################################################################################ +# llmapi.py +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +################################################################################ + +"""ZMS LLM API utility module + +This module provides an abstract interface for Large Language Model providers. +All providers follow the OpenAI /v1/chat/completions API schema for consistency. + +Supported providers: +- OpenAI (gpt-4, gpt-3.5-turbo, etc.) +- Ollama (local deployment) +- RAG with Qdrant vector database + +Configuration properties: +- llm.provider: 'openai', 'ollama', or 'rag' (default: 'openai') +- llm.api.key: API key for OpenAI (if provider is 'openai') +- llm.api.model: Model name (default: 'gpt-4o-mini' for OpenAI, 'llama2' for Ollama) +- llm.api.endpoint: Custom endpoint URL +- llm.ollama.host: Ollama host (default: 'http://localhost:11434') +- llm.qdrant.host: Qdrant host (default: 'http://localhost:6333') +- llm.qdrant.collection: Qdrant collection name (default: 'zms_docs') +- llm.embedding.model: SentenceTransformer model (default: 'all-MiniLM-L6-v2') +- llm.rag.top_k: Number of documents to retrieve (default: '3') +- llm.rag.score_threshold: Minimum similarity score (0.0-1.0, default: '0.0') +- llm.temperature: LLM temperature 0.0-2.0 (default: '0.7', RAG: 0.1 recommended) +- llm.top_p: Nucleus sampling 0.0-1.0 (default: '0.9') +- llm.max_tokens: Maximum tokens to generate (optional) +- llm.num_ctx: Context window size (default: '4096') +- llm.store: Enable storage for 'responses' API (default: False) + +Response format (OpenAI /v1/chat/completions compatible): +{ + "id": "chatcmpl-123", + "object": "chat.completion", + "created": 1677652288, + "model": "gpt-4o-mini", + "choices": [{ + "index": 0, + "message": { + "role": "assistant", + "content": "Response text" + }, + "finish_reason": "stop" + }], + "usage": { + "prompt_tokens": 10, + "completion_tokens": 20, + "total_tokens": 30 + } +} + +For backwards compatibility, a convenience property 'message' is also provided +at the top level containing the first choice's message. + +Requirements for RAG: +- pip install sentence-transformers +""" + +# Imports. +from AccessControl.SecurityInfo import ModuleSecurityInfo +import requests +import json +import time +import hashlib + +# Global cache for embedding model (singleton) +_EMBEDDING_MODEL_CACHE = {} + +security = ModuleSecurityInfo('Products.zms.llmapi') + + +def _generate_request_id(provider, model, message): + """Generate a unique request ID for tracking""" + timestamp = str(time.time()) + content = f"{provider}:{model}:{message}:{timestamp}" + hash_digest = hashlib.md5(content.encode('utf-8')).hexdigest()[:8] + return f"chatcmpl-{hash_digest}" + + +def _normalize_response(response_data, provider, model, original_message): + """ + Normalize provider-specific responses to OpenAI /v1/chat/completions format. + + This ensures all providers return a consistent schema compatible with the + OpenAI API and the upcoming 'responses' schema. + + Args: + response_data: Raw response from provider + provider: Provider name ('openai', 'ollama', 'rag') + model: Model name used + original_message: Original user message + + Returns: + dict: Normalized response in OpenAI format + """ + # Handle error responses + if 'error' in response_data: + return response_data + + # If already in OpenAI format (from OpenAI provider), ensure backwards compatibility + if 'choices' in response_data: + # Add convenience 'message' property for backwards compatibility + if response_data['choices'] and 'message' not in response_data: + response_data['message'] = response_data['choices'][0].get('message', {}) + return response_data + + # Normalize Ollama/RAG format to OpenAI format + if 'message' in response_data: + normalized = { + "id": _generate_request_id(provider, model, original_message), + "object": "chat.completion", + "created": int(time.time()), + "model": model, + "choices": [{ + "index": 0, + "message": response_data['message'], + "finish_reason": "stop" + }], + "usage": { + "prompt_tokens": 0, # Not provided by Ollama + "completion_tokens": 0, + "total_tokens": 0 + } + } + # Add backwards compatibility + normalized['message'] = response_data['message'] + return normalized + + # Unexpected format + return { + 'error': { + 'code': 'INVALID_RESPONSE', + 'message': 'Unexpected response format from provider' + } + } + + +class LLMProvider: + """Abstract base class for LLM providers""" + + def __init__(self, context): + self.context = context + + def chat(self, messages, **kwargs): + """ + Send messages to the LLM and get a response. + + Args: + messages (list|str): List of message dicts [{"role": "user", "content": "..."}] + or a string for simple single-turn conversations + **kwargs: Additional provider-specific parameters + + Returns: + dict: Response in OpenAI /v1/chat/completions format or error dict + """ + raise NotImplementedError("Subclasses must implement chat()") + + def _prepare_messages(self, messages): + """Convert string message to proper messages array""" + if isinstance(messages, str): + return [{"role": "user", "content": messages}] + elif isinstance(messages, list): + return messages + else: + raise ValueError("messages must be a string or list of message dicts") + + +class OpenAIProvider(LLMProvider): + """OpenAI API provider (v1/chat/completions compatible)""" + + def chat(self, messages, **kwargs): + """Send messages to OpenAI's /v1/chat/completions API""" + try: + api_key = self.context.getConfProperty('llm.api.key') + if not api_key: + return { + 'error': { + 'code': 'CONFIGURATION_ERROR', + 'message': 'OpenAI API key not configured. Set llm.api.key' + } + } + + model = self.context.getConfProperty('llm.api.model', 'gpt-4o-mini') + endpoint = self.context.getConfProperty('llm.api.endpoint', 'https://api.openai.com/v1/chat/completions') + + # Prepare messages array + messages_array = self._prepare_messages(messages) + + # Build request payload according to OpenAI spec + payload = { + "model": model, + "messages": messages_array, + } + + # Add optional parameters from config or kwargs + if 'temperature' in kwargs: + payload['temperature'] = float(kwargs['temperature']) + elif self.context.getConfProperty('llm.temperature'): + payload['temperature'] = float(self.context.getConfProperty('llm.temperature', '0.7')) + + if 'top_p' in kwargs: + payload['top_p'] = float(kwargs['top_p']) + elif self.context.getConfProperty('llm.top_p'): + payload['top_p'] = float(self.context.getConfProperty('llm.top_p', '0.9')) + + if 'max_tokens' in kwargs: + payload['max_tokens'] = int(kwargs['max_tokens']) + elif self.context.getConfProperty('llm.max_tokens'): + payload['max_tokens'] = int(self.context.getConfProperty('llm.max_tokens')) + + # Enable storage for responses API if configured + if 'store' in kwargs: + payload['store'] = bool(kwargs['store']) + elif self.context.getConfProperty('llm.store'): + payload['store'] = self.context.getConfProperty('llm.store', '').lower() in ['true', '1', 'yes'] + + # Add metadata for responses API + if 'metadata' in kwargs: + payload['metadata'] = kwargs['metadata'] + + # Add any other kwargs (streaming, functions, tools, etc.) + for key, value in kwargs.items(): + if key not in ['temperature', 'top_p', 'max_tokens', 'store', 'metadata']: + payload[key] = value + + response = requests.post( + endpoint, + headers={ + "Content-Type": "application/json", + "Authorization": f"Bearer {api_key}", + }, + json=payload, + timeout=30 + ) + + result = response.json() + + # Handle OpenAI error responses + if 'error' in result: + return { + 'error': { + 'code': result['error'].get('code', 'UNKNOWN'), + 'message': result['error'].get('message', 'Unknown error') + } + } + + # Return full OpenAI response (includes id, object, created, choices, usage) + # Add backwards compatibility convenience property + if 'choices' in result and len(result['choices']) > 0: + result['message'] = result['choices'][0].get('message', {}) + + return result + + except requests.exceptions.RequestException as e: + return { + 'error': { + 'code': 'REQUEST_ERROR', + 'message': f'Request to OpenAI failed: {str(e)}' + } + } + except Exception as e: + return { + 'error': { + 'code': 'INTERNAL_ERROR', + 'message': f'Internal error: {str(e)}' + } + } + + +class OllamaProvider(LLMProvider): + """Ollama local LLM provider (normalized to OpenAI format)""" + + def chat(self, messages, **kwargs): + """Send messages to Ollama and normalize response to OpenAI format""" + try: + host = self.context.getConfProperty('llm.ollama.host', 'http://localhost:11434') + model = self.context.getConfProperty('llm.api.model', 'llama2') + endpoint = f"{host}/api/chat" + + # Prepare messages array + messages_array = self._prepare_messages(messages) + + # Build Ollama request + payload = { + "model": model, + "messages": messages_array, + "stream": False, + } + + # Add Ollama-specific options + options = {} + if 'temperature' in kwargs: + options['temperature'] = float(kwargs['temperature']) + elif self.context.getConfProperty('llm.temperature'): + options['temperature'] = float(self.context.getConfProperty('llm.temperature', '0.7')) + + if 'top_p' in kwargs: + options['top_p'] = float(kwargs['top_p']) + elif self.context.getConfProperty('llm.top_p'): + options['top_p'] = float(self.context.getConfProperty('llm.top_p', '0.9')) + + if 'num_ctx' in kwargs: + options['num_ctx'] = int(kwargs['num_ctx']) + elif self.context.getConfProperty('llm.num_ctx'): + options['num_ctx'] = int(self.context.getConfProperty('llm.num_ctx', '4096')) + + if options: + payload['options'] = options + + # Add any other kwargs + for key, value in kwargs.items(): + if key not in ['temperature', 'top_p', 'num_ctx']: + payload[key] = value + + response = requests.post( + endpoint, + headers={"Content-Type": "application/json"}, + json=payload, + timeout=60 + ) + + result = response.json() + + # Normalize Ollama response to OpenAI format + original_msg = messages_array[0]['content'] if messages_array else '' + return _normalize_response(result, 'ollama', model, original_msg) + + except requests.exceptions.ConnectionError: + return { + 'error': { + 'code': 'CONNECTION_ERROR', + 'message': f'Cannot connect to Ollama at {host}. Is Ollama running?' + } + } + except requests.exceptions.RequestException as e: + return { + 'error': { + 'code': 'REQUEST_ERROR', + 'message': f'Request to Ollama failed: {str(e)}' + } + } + except Exception as e: + return { + 'error': { + 'code': 'INTERNAL_ERROR', + 'message': f'Internal error: {str(e)}' + } + } + + +class RAGProvider(LLMProvider): + """RAG (Retrieval-Augmented Generation) provider using Qdrant and Ollama""" + + def _get_embedding_model(self): + """Get cached embedding model (singleton pattern to avoid repeated HuggingFace API calls)""" + model_name = self.context.getConfProperty('llm.embedding.model', 'all-MiniLM-L6-v2') + + # Use global cache to avoid reloading model for each request + if model_name not in _EMBEDDING_MODEL_CACHE: + try: + from sentence_transformers import SentenceTransformer + _EMBEDDING_MODEL_CACHE[model_name] = SentenceTransformer(model_name) + except ImportError: + raise ImportError( + "sentence-transformers is required for RAG. " + "Install with: pip install sentence-transformers" + ) + return _EMBEDDING_MODEL_CACHE[model_name] + + def chat(self, messages, **kwargs): + """Send messages using RAG with vector search and LLM (normalized to OpenAI format)""" + try: + qdrant_host = self.context.getConfProperty('llm.qdrant.host', 'http://localhost:6333') + collection = self.context.getConfProperty('llm.qdrant.collection', 'zms_docs') + ollama_host = self.context.getConfProperty('llm.ollama.host', 'http://localhost:11434') + model = self.context.getConfProperty('llm.api.model', 'llama2') + top_k = int(self.context.getConfProperty('llm.rag.top_k', '16')) + score_threshold = float(self.context.getConfProperty('llm.rag.score_threshold', '0.0')) + + # Prepare messages array + messages_array = self._prepare_messages(messages) + + # Extract the last user message for RAG retrieval + user_message = None + for msg in reversed(messages_array): + if msg.get('role') == 'user': + user_message = msg.get('content', '') + break + + if not user_message: + return { + 'error': { + 'code': 'INVALID_REQUEST', + 'message': 'No user message found in messages array' + } + } + + # Get LLM parameters with RAG-optimized defaults + temperature = float(kwargs.get('temperature') or self.context.getConfProperty('llm.temperature', '0.1')) + top_p = float(kwargs.get('top_p') or self.context.getConfProperty('llm.top_p', '0.9')) + num_ctx = int(kwargs.get('num_ctx') or self.context.getConfProperty('llm.num_ctx', '4096')) + + # Step 1: Generate embeddings for the query + try: + embedding_model = self._get_embedding_model() + query_vector = embedding_model.encode(user_message).tolist() + except Exception as e: + return { + 'error': { + 'code': 'EMBEDDING_ERROR', + 'message': f'Failed to generate embeddings: {str(e)}' + } + } + + # Step 2: Search Qdrant for relevant context using embeddings + context_docs = [] + try: + search_payload = { + "query": query_vector, + "limit": top_k, + "with_payload": True + } + + # Add score threshold if configured + if score_threshold > 0: + search_payload["score_threshold"] = score_threshold + + search_response = requests.post( + f"{qdrant_host}/collections/{collection}/points/query", + headers={"Content-Type": "application/json"}, + json=search_payload, + timeout=10 + ) + + if search_response.status_code == 200: + results = search_response.json() + if 'result' in results and 'points' in results['result']: + for doc in results['result']['points']: + payload = doc.get('payload', {}) + # Extract text from payload (adapt to your data structure) + text = payload.get('text') or payload.get('body') or payload.get('content', '') + if text: + context_docs.append(text) + elif 'result' in results: + # Fallback for different Qdrant response formats + for doc in results['result']: + payload = doc.get('payload', {}) + text = payload.get('text') or payload.get('body') or payload.get('content', '') + if text: + context_docs.append(text) + except Exception as e: + # If Qdrant search fails, continue without context + import traceback + traceback.print_exc() + + # Step 3: Build enhanced messages with context + enhanced_messages = messages_array.copy() + if context_docs: + context_text = "\n\n---\n\n".join(context_docs) + # Find the last user message and enhance it + for i in range(len(enhanced_messages) - 1, -1, -1): + if enhanced_messages[i].get('role') == 'user': + enhanced_messages[i] = { + "role": "user", + "content": f"""Basierend auf den folgenden Informationen, beantworte die Frage präzise und sachlich. +Verwende nur Informationen aus dem bereitgestellten Kontext. + +KONTEXT: +{context_text} + +FRAGE: {user_message} + +ANTWORT:""" + } + break + + # Step 4: Send to Ollama with context and optimized parameters + ollama_params = { + "model": model, + "messages": enhanced_messages, + "stream": False, + "options": { + "temperature": temperature, + "top_p": top_p, + "num_ctx": num_ctx + } + } + + # Add any additional kwargs + for key, value in kwargs.items(): + if key not in ['temperature', 'top_p', 'num_ctx']: + ollama_params[key] = value + + response = requests.post( + f"{ollama_host}/api/chat", + headers={"Content-Type": "application/json"}, + json=ollama_params, + timeout=120 + ) + + result = response.json() + + # Normalize RAG response to OpenAI format + return _normalize_response(result, 'rag', model, user_message) + + except requests.exceptions.ConnectionError as e: + return { + 'error': { + 'code': 'CONNECTION_ERROR', + 'message': f'Cannot connect to services. Check Qdrant and Ollama: {str(e)}' + } + } + except Exception as e: + return { + 'error': { + 'code': 'INTERNAL_ERROR', + 'message': f'Internal error in RAG: {str(e)}' + } + } + + +def _get_provider(context): + """ + Factory function to get the appropriate LLM provider based on configuration. + + Args: + context: ZMS context object + + Returns: + LLMProvider: An instance of the configured provider + """ + provider_type = context.getConfProperty('llm.provider', 'openai').lower() + + providers = { + 'openai': OpenAIProvider, + 'ollama': OllamaProvider, + 'rag': RAGProvider, + } + + provider_class = providers.get(provider_type, OpenAIProvider) + return provider_class(context) + + +security.declarePublic('chat') +def chat(context, messages, **kwargs): + """ + Send messages to the configured LLM provider and get a response. + + This is the main entry point for LLM interactions in ZMS. + All responses follow the OpenAI /v1/chat/completions format. + + Args: + context: ZMS context object + messages (list|str): List of message dicts [{"role": "user", "content": "..."}] + or a string for backwards compatibility + **kwargs: Additional provider-specific parameters: + - temperature (float): Sampling temperature 0.0-2.0 + - top_p (float): Nucleus sampling 0.0-1.0 + - max_tokens (int): Maximum tokens to generate + - store (bool): Enable storage for responses API + - metadata (dict): Metadata for responses API + + Returns: + dict: Response in OpenAI /v1/chat/completions format: + Success: { + "id": "chatcmpl-123", + "object": "chat.completion", + "created": 1677652288, + "model": "gpt-4o-mini", + "choices": [{ + "index": 0, + "message": { + "role": "assistant", + "content": "Response text" + }, + "finish_reason": "stop" + }], + "usage": { + "prompt_tokens": 10, + "completion_tokens": 20, + "total_tokens": 30 + }, + "message": {...} # Backwards compatibility: first choice's message + } + + Error: { + "error": { + "code": "ERROR_CODE", + "message": "error description" + } + } + + Configuration: + Set llm.provider to one of: 'openai', 'ollama', 'rag' + + For OpenAI: + - llm.api.key: Your OpenAI API key + - llm.api.model: Model name (default: 'gpt-4o-mini') + - llm.api.endpoint: Custom endpoint (default: https://api.openai.com/v1/chat/completions) + - llm.store: Enable responses API storage (default: False) + + For Ollama: + - llm.ollama.host: Ollama server URL (default: 'http://localhost:11434') + - llm.api.model: Model name (default: 'llama2') + + For RAG: + - llm.qdrant.host: Qdrant server URL (default: 'http://localhost:6333') + - llm.qdrant.collection: Collection name (default: 'zms_docs') + - llm.ollama.host: Ollama server URL (default: 'http://localhost:11434') + - llm.api.model: Model name (default: 'llama2') + - llm.rag.top_k: Number of documents to retrieve (default: '3') + """ + provider = _get_provider(context) + return provider.chat(messages, **kwargs) + + +security.declarePublic('get_provider_info') +def get_provider_info(context): + """ + Get information about the currently configured LLM provider. + + Args: + context: ZMS context object + + Returns: + dict: Provider information including type, model, and endpoint + """ + provider_type = context.getConfProperty('llm.provider', 'openai').lower() + + info = { + 'provider': provider_type, + 'model': context.getConfProperty('llm.api.model', 'not configured'), + } + + if provider_type == 'openai': + info['endpoint'] = context.getConfProperty('llm.api.endpoint', 'https://api.openai.com/v1/chat/completions') + info['has_api_key'] = bool(context.getConfProperty('llm.api.key')) + info['store_enabled'] = context.getConfProperty('llm.store', '').lower() in ['true', '1', 'yes'] + elif provider_type == 'ollama': + info['endpoint'] = context.getConfProperty('llm.ollama.host', 'http://localhost:11434') + elif provider_type == 'rag': + info['ollama_host'] = context.getConfProperty('llm.ollama.host', 'http://localhost:11434') + info['qdrant_host'] = context.getConfProperty('llm.qdrant.host', 'http://localhost:6333') + info['collection'] = context.getConfProperty('llm.qdrant.collection', 'zms_docs') + info['top_k'] = context.getConfProperty('llm.rag.top_k', '3') + + return info + + +security.apply(globals()) \ No newline at end of file diff --git a/Products/zms/plugins/www/bootstrap/plugin/bootstrap.plugin.zmi.js b/Products/zms/plugins/www/bootstrap/plugin/bootstrap.plugin.zmi.js index e20f0b068..67e4136da 100644 --- a/Products/zms/plugins/www/bootstrap/plugin/bootstrap.plugin.zmi.js +++ b/Products/zms/plugins/www/bootstrap/plugin/bootstrap.plugin.zmi.js @@ -124,6 +124,17 @@ $ZMI.registerReady(function(){ } }); + // Toggle: LLM + $('a#navbar-llm').each(function() { + var $a = $(this); + if (self.window.parent.frames.length > 1 && typeof self.window.parent != "undefined" && typeof self.window.parent.frames.manage_llm != "undefined") { + $a.attr('target','_top'); + } + else { + $a.attr('href',$a.attr('href')+'&dtpref_llm=1'); + } + }); + // Toggle: Lang if (manage_menu) { $('.zmi header a.toggle-lang').each(function() { diff --git a/Products/zms/plugins/www/object/manage_llm.js b/Products/zms/plugins/www/object/manage_llm.js new file mode 100644 index 000000000..e69de29bb diff --git a/Products/zms/rest_api.py b/Products/zms/rest_api.py index 316d84cb2..edca7d2da 100644 --- a/Products/zms/rest_api.py +++ b/Products/zms/rest_api.py @@ -22,6 +22,7 @@ # Product Imports. from Products.zms import _blobfields from Products.zms import mock_http +from Products.zms import llmapi from Products.zms import standard class api(object): @@ -215,6 +216,13 @@ def __call__(self, REQUEST=None, **kw): decoration, data = self.body_content(self.context, content_type=True) elif self.ids == [] or self.ids == ['get']: decoration, data = self.get(self.context, content_type=True) + elif self.ids == ['llm_chat']: + message = REQUEST['message'] + data = llmapi.chat(self.context, message) + decoration = {'content_type':'application/json'} + elif self.ids == ['llm_provider_info']: + data = llmapi.get_provider_info(self.context) + decoration = {'content_type':'application/json'} else: data = {'ERROR':'Not Found','context':str(self.context),'path_to_handle':self.path_to_handle,'ids':self.ids} ct = decoration['content_type'] diff --git a/Products/zms/version.txt b/Products/zms/version.txt index 307a47429..11e7d9e20 100644 --- a/Products/zms/version.txt +++ b/Products/zms/version.txt @@ -1 +1 @@ -2025.9.1+208c2f5 +2025.9.1+b4e0ac7 diff --git a/Products/zms/zmscustom.py b/Products/zms/zmscustom.py index 1a9796858..3e435ec3c 100644 --- a/Products/zms/zmscustom.py +++ b/Products/zms/zmscustom.py @@ -202,6 +202,7 @@ def manage_options(self): # ---------- manage_properties = PageTemplateFile('zpt/ZMSObject/manage_main', globals()) manage_menu = PageTemplateFile('zpt/object/manage_menu', globals()) + manage_llm = PageTemplateFile('zpt/object/manage_llm', globals()) metaobj_recordset_main_grid = PageTemplateFile('zpt/ZMSRecordSet/main_grid', globals()) metaobj_recordset_main = PageTemplateFile('zpt/ZMSRecordSet/main', globals()) metaobj_recordset_input_fields = PageTemplateFile('zpt/ZMSRecordSet/input_fields', globals()) diff --git a/Products/zms/zpt/common/zmi_body_header.zpt b/Products/zms/zpt/common/zmi_body_header.zpt index 765f1d1ae..df4bd1e37 100644 --- a/Products/zms/zpt/common/zmi_body_header.zpt +++ b/Products/zms/zpt/common/zmi_body_header.zpt @@ -2,7 +2,9 @@
@@ -15,10 +17,14 @@ +
  • diff --git a/Products/zms/zpt/object/manage.zpt b/Products/zms/zpt/object/manage.zpt index 78cefd084..77448fbfe 100644 --- a/Products/zms/zpt/object/manage.zpt +++ b/Products/zms/zpt/object/manage.zpt @@ -1,8 +1,9 @@ - + @@ -13,12 +14,15 @@ - - - - + + + + + - redirect to target + redirect to target diff --git a/Products/zms/zpt/object/manage_llm.zpt b/Products/zms/zpt/object/manage_llm.zpt new file mode 100644 index 000000000..b44417c28 --- /dev/null +++ b/Products/zms/zpt/object/manage_llm.zpt @@ -0,0 +1,180 @@ + + +zmi_html_head + +
    + +    + LLM Chat + +
    + +
    +
    +
    +
    + + +
    +
    +
    + +zmi_html_foot + + + + + \ No newline at end of file diff --git a/docker/addons/llm/README.md b/docker/addons/llm/README.md new file mode 100644 index 000000000..edc72b4bd --- /dev/null +++ b/docker/addons/llm/README.md @@ -0,0 +1,119 @@ +# ZMS LLM Integration + +## Quick Start + +### Option 1: OpenAI (Cloud) + +1. Get an API key from [OpenAI](https://platform.openai.com/api-keys) +2. Configure in ZMS: + ```python + llm.provider = openai + llm.api.key = sk-your-key-here + llm.api.model = gpt-4o-mini + ``` + +### Option 2: Ollama (Local) + +1. Start Ollama service: + ```bash + cd docker/addons/llm + docker compose -f docker-compose.llm.yml up -d ollama + docker exec -it zms_ollama ollama pull llama2 + ``` + +2. Configure in ZMS: + ```python + llm.provider = ollama + llm.ollama.host = http://localhost:11434 + llm.api.model = llama2 + ``` + +### Option 3: RAG with Qdrant + +1. Start both services: + ```bash + cd docker/addons/llm + docker compose -f docker-compose.llm.yml up -d + docker exec -it zms_ollama ollama pull llama2 + ``` + +2. Configure in ZMS: + ```python + llm.provider = rag + llm.ollama.host = http://localhost:11434 + llm.qdrant.host = http://localhost:6333 + llm.qdrant.collection = zms_docs + llm.api.model = llama2 + ``` + + +## Features + +- **Multi-provider support**: Switch between OpenAI, Ollama, or RAG without code changes +- **Docker-ready**: Includes docker-compose setup for local deployment +- **REST API**: Access via `++rest_api/llm_chat` endpoint +- **Provider info**: Check current configuration via `++rest_api/llm_provider_info` + + +## Files + +- `llmapi.py` - Main LLM API module with provider abstraction +- `docker/llm/docker-compose.llm.yml` - Docker setup for Ollama and Qdrant +- `docs/llm_configuration.md` - Complete configuration guide +- `tests/test_llmapi.py` - Unit tests + +## Architecture + +``` +┌─────────────────┐ +│ ZMS Interface │ +│ (manage_llm) │ +└────────┬────────┘ + │ + ▼ +┌─────────────────┐ +│ llmapi.chat() │ +│ (REST API) │ +└────────┬────────┘ + │ + ┌────┴────┐ + │ Provider│ + │ Factory │ + └────┬────┘ + │ + ┌────┴────────────────────────┐ + │ │ + ▼ ▼ +┌──────────┐ ┌──────────┐ ┌──────────┐ +│ OpenAI │ │ Ollama │ │ RAG │ +│ Provider │ │ Provider │ │ Provider │ +└──────────┘ └──────────┘ └────┬─────┘ + │ + ┌─────┴─────┐ + ▼ ▼ + ┌────────┐ ┌────────┐ + │ Qdrant │ │ Ollama │ + │(Vector)│ │ (LLM) │ + └────────┘ └────────┘ +``` + + +## Documentation + +See [docs/llm_configuration.md](../../../docs/llm_configuration.md) for: +- Complete configuration reference +- Docker setup instructions +- RAG with Qdrant setup +- Troubleshooting guide +- API usage examples +- Best practices + +## Testing + +Run the unit tests: + +```bash +cd tests +python test_llmapi.py +``` + diff --git a/docker/addons/llm/docker-compose.llm.yml b/docker/addons/llm/docker-compose.llm.yml new file mode 100644 index 000000000..7beac56ee --- /dev/null +++ b/docker/addons/llm/docker-compose.llm.yml @@ -0,0 +1,96 @@ +version: '3.8' + +# Example Docker Compose setup for ZMS with LLM providers +# This adds Ollama and Qdrant services to support local LLM capabilities + +services: + # Ollama - Local LLM server + ollama: + image: ollama/ollama:latest + container_name: zms_ollama + ports: + - "11434:11434" + volumes: + - ollama_data:/root/.ollama + networks: + - zms_network + restart: unless-stopped + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"] + interval: 30s + timeout: 10s + retries: 3 + + # Qdrant - Vector database for RAG + qdrant: + image: qdrant/qdrant:latest + container_name: zms_qdrant + ports: + - "6333:6333" # REST API + - "6334:6334" # gRPC API + volumes: + - qdrant_storage:/qdrant/storage + networks: + - zms_network + restart: unless-stopped + environment: + - QDRANT__SERVICE__GRPC_PORT=6334 + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:6333/health"] + interval: 30s + timeout: 10s + retries: 3 + +volumes: + ollama_data: + driver: local + qdrant_storage: + driver: local + +networks: + zms_network: + driver: bridge + +# Usage Instructions: +# +# 1. Start the services: +# docker-compose -f docker-compose.llm.yml up -d +# +# 2. Pull an Ollama model: +# docker exec -it zms_ollama ollama pull llama2 +# # or +# docker exec -it zms_ollama ollama pull mistral +# +# 3. Configure ZMS with these properties: +# +# For Ollama: +# llm.provider = ollama +# llm.ollama.host = http://ollama:11434 +# llm.api.model = llama2 +# +# For RAG: +# llm.provider = rag +# llm.ollama.host = http://ollama:11434 +# llm.qdrant.host = http://qdrant:6333 +# llm.qdrant.collection = zms_docs +# llm.api.model = llama2 +# +# 4. (Optional) Populate Qdrant with your documents for RAG +# +# 5. Access the services: +# - Ollama API: http://localhost:11434 +# - Qdrant Dashboard: http://localhost:6333/dashboard +# +# Available Ollama models: +# - llama2 (7B, 13B, 70B variants) +# - mistral (7B) +# - codellama (for code generation) +# - neural-chat (optimized for chat) +# - starling-lm (high quality responses) +# +# To see all available models: +# docker exec -it zms_ollama ollama list +# +# To pull a specific model variant: +# docker exec -it zms_ollama ollama pull llama2:7b +# docker exec -it zms_ollama ollama pull llama2:13b diff --git a/docs/llm_configuration.md b/docs/llm_configuration.md new file mode 100644 index 000000000..8f46dadb4 --- /dev/null +++ b/docs/llm_configuration.md @@ -0,0 +1,468 @@ +# LLM API Configuration Guide + +ZMS now supports multiple Large Language Model (LLM) providers through an abstract interface. This allows you to use different AI backends including OpenAI, local Ollama deployments, and RAG (Retrieval-Augmented Generation) with Qdrant vector database. + +## Overview + +The LLM integration provides a chat interface accessible from the ZMS management interface. You can configure different providers based on your needs: + +- **OpenAI**: Cloud-based GPT models (requires API key and internet connection) +- **Ollama**: Local LLM deployment (no API key needed, runs on your infrastructure) +- **RAG**: Retrieval-Augmented Generation using Qdrant vector database with Ollama + +## Configuration Properties + +All configuration is done via ZMS configuration properties. Set these in your ZMS instance configuration. + +### General Settings + +| Property | Description | Default | +|----------|-------------|---------| +| `llm.provider` | Provider type: `openai`, `ollama`, or `rag` | `openai` | +| `llm.api.model` | Model name to use | `gpt-4o-mini` (OpenAI), `llama2` (Ollama) | +| `llm.temperature` | Sampling temperature 0.0-2.0 (higher = more creative) | `0.7` (RAG: `0.1` recommended) | +| `llm.top_p` | Nucleus sampling 0.0-1.0 | `0.9` | +| `llm.max_tokens` | Maximum tokens to generate (optional) | (not set) | +| `llm.num_ctx` | Context window size for Ollama/RAG | `4096` | + +### OpenAI Configuration + +For using OpenAI's cloud API: + +| Property | Description | Default | +|----------|-------------|---------| +| `llm.api.key` | Your OpenAI API key | (required) | +| `llm.api.endpoint` | Custom endpoint URL | `https://api.openai.com/v1/chat/completions` | +| `llm.api.model` | Model name | `gpt-4o-mini` | +| `llm.store` | Enable storage for OpenAI's responses API | `False` | + +### Ollama Configuration + +For using local Ollama deployment: + +| Property | Description | Default | +|----------|-------------|---------| +| `llm.ollama.host` | Ollama server URL | `http://localhost:11434` | +| `llm.api.model` | Model name (e.g., `llama2`, `mistral`, `codellama`) | `llama2` | +| `llm.num_ctx` | Context window size | `4096` | + +### RAG Configuration + +For using RAG with Qdrant vector database and Ollama: + +| Property | Description | Default | +|----------|-------------|---------| +| `llm.qdrant.host` | Qdrant server URL | `http://localhost:6333` | +| `llm.qdrant.collection` | Collection name for vector search | `zms_docs` | +| `llm.ollama.host` | Ollama server URL | `http://localhost:11434` | +| `llm.api.model` | Model name | `llama2` | +| `llm.embedding.model` | SentenceTransformer model for embeddings | `all-MiniLM-L6-v2` | +| `llm.rag.top_k` | Number of documents to retrieve | `16` | +| `llm.rag.score_threshold` | Minimum similarity score (0.0-1.0) | `0.0` | +| `llm.temperature` | Temperature for RAG responses | `0.1` (recommended) | +| `llm.num_ctx` | Context window size | `4096` | + +**Important**: RAG requires the `sentence-transformers` package: +```bash +pip install sentence-transformers +``` + +## Configuration Examples + +### Example 1: OpenAI (Cloud) + +```python +# In your ZMS configuration +llm.provider = openai +llm.api.key = sk-your-openai-api-key-here +llm.api.model = gpt-4o-mini +llm.temperature = 0.7 +llm.top_p = 0.9 +llm.store = True # Enable responses API storage +``` + +### Example 2: Ollama (Local) + +```python +# In your ZMS configuration +llm.provider = ollama +llm.ollama.host = http://localhost:11434 +llm.api.model = llama2 +llm.temperature = 0.7 +llm.num_ctx = 4096 +``` + +For Docker deployments, you might use: +```python +llm.provider = ollama +llm.ollama.host = http://ollama:11434 # Docker service name +llm.api.model = mistral +llm.temperature = 0.8 +llm.num_ctx = 8192 +``` + +### Example 3: RAG with Qdrant + +```python +# In your ZMS configuration +llm.provider = rag +llm.qdrant.host = http://localhost:6333 +llm.qdrant.collection = zms_documentation +llm.ollama.host = http://localhost:11434 +llm.api.model = llama2 +llm.embedding.model = all-MiniLM-L6-v2 +llm.rag.top_k = 16 +llm.rag.score_threshold = 0.0 +llm.temperature = 0.1 # Lower temperature for factual answers +llm.num_ctx = 4096 +``` + +For Docker Compose setup: +```python +llm.provider = rag +llm.qdrant.host = http://qdrant:6333 +llm.ollama.host = http://ollama:11434 +llm.qdrant.collection = zms_docs +llm.api.model = llama2 +llm.embedding.model = all-MiniLM-L6-v2 +llm.rag.top_k = 16 +llm.rag.score_threshold = 0.3 # Filter low-quality matches +llm.temperature = 0.1 +``` + +**Note**: Make sure to use the same embedding model (`llm.embedding.model`) that was used to ingest your data into Qdrant! + +## Setting Up Ollama + +### Installation + +1. **Install Ollama**: Visit [https://ollama.ai](https://ollama.ai) and download for your platform +2. **Pull a model**: + ```bash + ollama pull llama2 + # or + ollama pull mistral + # or + ollama pull codellama + ``` +3. **Start Ollama**: + ```bash + ollama serve + ``` + +### Docker Setup + +Add to your `docker-compose.yml`: + +```yaml +services: + ollama: + image: ollama/ollama:latest + ports: + - "11434:11434" + volumes: + - ollama_data:/root/.ollama + networks: + - zms_network + +volumes: + ollama_data: +``` + +Then pull your desired model: +```bash +docker exec -it ollama ollama pull llama2 +``` + +## Setting Up RAG with Qdrant + +### Docker Compose Setup + +```yaml +services: + qdrant: + image: qdrant/qdrant:latest + ports: + - "6333:6333" + - "6334:6334" + volumes: + - qdrant_storage:/qdrant/storage + networks: + - zms_network + + ollama: + image: ollama/ollama:latest + ports: + - "11434:11434" + volumes: + - ollama_data:/root/.ollama + networks: + - zms_network + +volumes: + qdrant_storage: + ollama_data: + +networks: + zms_network: +``` + +### Populate Qdrant + +You'll need to populate your Qdrant collection with embeddings. Here's a Python example: + +```python +from qdrant_client import QdrantClient +from qdrant_client.models import Distance, VectorParams, PointStruct +from sentence_transformers import SentenceTransformer + +# Initialize embedding model (use the same as llm.embedding.model) +model = SentenceTransformer('all-MiniLM-L6-v2') + +# Connect to Qdrant +client = QdrantClient(host="localhost", port=6333) + +# Create collection +client.create_collection( + collection_name="zms_docs", + vectors_config=VectorParams(size=384, distance=Distance.COSINE), +) + +# Add documents with embeddings +documents = [ + "ZMS is a content management system...", + "To configure LLM settings...", + # ... your documents +] + +points = [] +for idx, doc in enumerate(documents): + vector = model.encode(doc).tolist() + points.append( + PointStruct( + id=idx, + vector=vector, + payload={"text": doc} + ) + ) + +client.upsert(collection_name="zms_docs", points=points) +``` + +## API Usage + +### REST API Endpoint + +The LLM chat is available via REST API: + +``` +GET /++rest_api/llm_chat?message=Your+question+here +``` + +Response format (OpenAI /v1/chat/completions compatible): +```json +{ + "id": "chatcmpl-abc123", + "object": "chat.completion", + "created": 1677652288, + "model": "gpt-4o-mini", + "choices": [{ + "index": 0, + "message": { + "role": "assistant", + "content": "The AI's response" + }, + "finish_reason": "stop" + }], + "usage": { + "prompt_tokens": 10, + "completion_tokens": 20, + "total_tokens": 30 + }, + "message": { + "role": "assistant", + "content": "The AI's response" + } +} +``` + +Error format: +```json +{ + "error": { + "code": "ERROR_CODE", + "message": "Error description" + } +} +``` + +### Provider Info Endpoint + +Get information about the current provider: + +``` +GET /++rest_api/llm_provider_info +``` + +Response: +```json +{ + "provider": "ollama", + "model": "llama2", + "endpoint": "http://localhost:11434" +} +``` + +### Python API + +You can use the LLM API from Python code: + +```python +from Products.zms import llmapi + +# Send a simple message (string) +response = llmapi.chat(context, "What is ZMS?") + +# Send a conversation (list of messages) +messages = [ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "What is ZMS?"} +] +response = llmapi.chat(context, messages) + +# With additional parameters +response = llmapi.chat( + context, + "Explain ZMS configuration", + temperature=0.5, + max_tokens=500 +) + +# Check for errors +if 'error' in response: + print(f"Error: {response['error']['message']}") +else: + # Access the response content + print(f"Response: {response['message']['content']}") + # Or using the OpenAI format + print(f"Response: {response['choices'][0]['message']['content']}") + +# Get provider info +info = llmapi.get_provider_info(context) +print(f"Using {info['provider']} with model {info['model']}") +``` + +## Configuration Parameters Explained + +### Temperature (`llm.temperature`) +Controls randomness in responses: +- **0.0**: Deterministic, always picks most likely tokens +- **0.7**: Balanced (default for general use) +- **0.1**: More focused and deterministic (recommended for RAG) +- **1.5-2.0**: Very creative, more random + +### Top P (`llm.top_p`) +Nucleus sampling threshold (0.0-1.0): +- **0.9**: Default, good balance +- Lower values = more focused responses +- Higher values = more diverse responses + +### Max Tokens (`llm.max_tokens`) +Maximum length of generated response. Useful to control costs or response length. + +### Context Window (`llm.num_ctx`) +Size of context window for Ollama/RAG models: +- **4096**: Default, good for most use cases +- **8192** or higher: For longer conversations or documents + +### Score Threshold (`llm.rag.score_threshold`) +Minimum similarity score for RAG document retrieval: +- **0.0**: Include all retrieved documents (default) +- **0.3-0.5**: Filter out low-quality matches +- **0.7+**: Only very relevant documents + +### Top K (`llm.rag.top_k`) +Number of documents to retrieve for RAG context: +- **3**: Quick, focused answers +- **16**: Default, good balance (updated from 3) +- **30+**: Comprehensive context (may exceed token limits) + +### Store (`llm.store`) +When set to `True`, enables OpenAI's responses API storage for model training and fine-tuning. + +## Troubleshooting + +### Connection Errors + +**Problem**: "Cannot connect to Ollama" or "Cannot connect to Qdrant" + +**Solutions**: +1. Check if the service is running: `curl http://localhost:11434/api/tags` (Ollama) +2. Check Docker containers: `docker ps` +3. Verify network connectivity between containers +4. Check firewall settings + +### Model Not Found + +**Problem**: "Model 'xyz' not found" + +**Solution**: Pull the model first: +```bash +ollama pull llama2 +# or in Docker +docker exec -it ollama ollama pull llama2 +``` + +### OpenAI API Key Issues + +**Problem**: "API key not configured" or "Invalid API key" + +**Solutions**: +1. Set `llm.api.key` property with your OpenAI API key +2. Verify the key is correct at [https://platform.openai.com/api-keys](https://platform.openai.com/api-keys) +3. Check for any whitespace in the key + +### Slow Responses + +**Problem**: Ollama responses are very slow + +**Solutions**: +1. Use a smaller model (e.g., `llama2:7b` instead of `llama2:13b`) +2. Increase Docker memory allocation +3. Use GPU acceleration if available +4. Consider using OpenAI for faster responses +5. Reduce `llm.num_ctx` if using very large context windows + +### RAG Not Finding Relevant Documents + +**Problem**: RAG returns generic answers or "I don't know" + +**Solutions**: +1. Check that documents are properly ingested in Qdrant +2. Verify `llm.embedding.model` matches the model used for ingestion +3. Lower `llm.rag.score_threshold` to include more documents +4. Increase `llm.rag.top_k` to retrieve more context +5. Check Qdrant collection: `curl http://localhost:6333/collections/zms_docs` + +## Best Practices + +1. **Use OpenAI for production** if you need reliable, fast responses and can afford the API costs +2. **Use Ollama for development** or when you need privacy and control over your data +3. **Use RAG** when you need the LLM to answer questions based on your specific documentation +4. **Monitor costs** when using OpenAI - set up billing alerts +5. **Test locally first** with Ollama before switching to OpenAI +6. **Keep models updated** - regularly update Ollama models for improvements +7. **Use lower temperature (0.1-0.3) for RAG** to ensure factual, grounded responses +8. **Match embedding models** - always use the same `llm.embedding.model` for ingestion and retrieval +9. **Tune score threshold** - adjust `llm.rag.score_threshold` based on your data quality +10. **Enable OpenAI storage** (`llm.store = True`) only if you want to contribute to model training + +## Security Considerations + +- Never commit API keys to version control +- Use environment variables for sensitive configuration +- Limit network access to Ollama/Qdrant in production +- Regularly rotate OpenAI API keys +- Use HTTPS endpoints when possible +- Implement rate limiting for the chat endpoint +- Be aware that `llm.store = True` sends your data to OpenAI for training diff --git a/tests/test_llmapi.py b/tests/test_llmapi.py new file mode 100644 index 000000000..abac38884 --- /dev/null +++ b/tests/test_llmapi.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Test script for LLM API functionality + +This script tests the different LLM providers without requiring a full ZMS instance. +""" + +class MockContext: + """Mock ZMS context for testing""" + def __init__(self, config=None): + self.config = config or {} + + def getConfProperty(self, key, default=None): + return self.config.get(key, default) + + +def test_provider_selection(): + """Test that the correct provider is selected based on configuration""" + print("Testing provider selection...") + + # Import after sys.path is set + import sys + import os + sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + + from Products.zms.llmapi import _get_provider, OpenAIProvider, OllamaProvider, RAGProvider + + # Test OpenAI provider + ctx = MockContext({'llm.provider': 'openai'}) + provider = _get_provider(ctx) + assert isinstance(provider, OpenAIProvider), "Should create OpenAI provider" + print("✓ OpenAI provider selected correctly") + + # Test Ollama provider + ctx = MockContext({'llm.provider': 'ollama'}) + provider = _get_provider(ctx) + assert isinstance(provider, OllamaProvider), "Should create Ollama provider" + print("✓ Ollama provider selected correctly") + + # Test RAG provider + ctx = MockContext({'llm.provider': 'rag'}) + provider = _get_provider(ctx) + assert isinstance(provider, RAGProvider), "Should create RAG provider" + print("✓ RAG provider selected correctly") + + # Test default (should be OpenAI) + ctx = MockContext({}) + provider = _get_provider(ctx) + assert isinstance(provider, OpenAIProvider), "Should default to OpenAI provider" + print("✓ Default provider (OpenAI) selected correctly") + + print("\nAll provider selection tests passed!") + + +def test_provider_info(): + """Test the get_provider_info function""" + print("\nTesting provider info...") + + import sys + import os + sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + + from Products.zms.llmapi import get_provider_info + + # Test OpenAI info + ctx = MockContext({ + 'llm.provider': 'openai', + 'llm.api.key': 'sk-test123', + 'llm.api.model': 'gpt-4' + }) + info = get_provider_info(ctx) + assert info['provider'] == 'openai' + assert info['model'] == 'gpt-4' + assert info['has_api_key'] == True + print("✓ OpenAI provider info correct") + + # Test Ollama info + ctx = MockContext({ + 'llm.provider': 'ollama', + 'llm.ollama.host': 'http://ollama:11434', + 'llm.api.model': 'llama2' + }) + info = get_provider_info(ctx) + assert info['provider'] == 'ollama' + assert info['model'] == 'llama2' + assert info['endpoint'] == 'http://ollama:11434' + print("✓ Ollama provider info correct") + + # Test RAG info + ctx = MockContext({ + 'llm.provider': 'rag', + 'llm.qdrant.host': 'http://qdrant:6333', + 'llm.qdrant.collection': 'docs', + 'llm.api.model': 'mistral' + }) + info = get_provider_info(ctx) + assert info['provider'] == 'rag' + assert info['qdrant_host'] == 'http://qdrant:6333' + assert info['collection'] == 'docs' + print("✓ RAG provider info correct") + + print("\nAll provider info tests passed!") + + +def test_configuration_error(): + """Test that missing API key returns proper error""" + print("\nTesting configuration error handling...") + + import sys + import os + sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + + from Products.zms.llmapi import OpenAIProvider + + # Test with missing API key + ctx = MockContext({ + 'llm.provider': 'openai' + }) + + provider = OpenAIProvider(ctx) + result = provider.chat("test message") + assert 'error' in result, "Should return error when API key is missing" + assert result['error']['code'] == 'CONFIGURATION_ERROR' + print("✓ Configuration error handling works correctly") + + print("\nConfiguration error tests passed!") + + +if __name__ == '__main__': + try: + test_provider_selection() + test_provider_info() + test_configuration_error() + print("\n" + "="*50) + print("All tests passed! ✓") + print("="*50) + except AssertionError as e: + print(f"\n❌ Test failed: {e}") + import traceback + traceback.print_exc() + exit(1) + except Exception as e: + print(f"\n❌ Error: {e}") + import traceback + traceback.print_exc() + exit(1)