547 lines
22 KiB
Python
547 lines
22 KiB
Python
# Copyright (c) 2025 Patrick Motsch
|
|
# All rights reserved.
|
|
"""
|
|
AI Center to LangChain bridge.
|
|
Implements LangChain BaseChatModel interface using AI center models.
|
|
"""
|
|
|
|
import logging
|
|
import asyncio
|
|
from typing import Any, AsyncIterator, Dict, List, Optional
|
|
from datetime import datetime
|
|
|
|
from langchain_core.language_models.chat_models import BaseChatModel
|
|
from langchain_core.messages import (
|
|
BaseMessage,
|
|
HumanMessage,
|
|
SystemMessage,
|
|
AIMessage,
|
|
ToolMessage,
|
|
convert_to_openai_messages,
|
|
)
|
|
from langchain_core.outputs import ChatGeneration, ChatResult
|
|
from langchain_core.runnables import RunnableConfig
|
|
|
|
from modules.aicore.aicoreModelRegistry import modelRegistry
|
|
from modules.aicore.aicoreModelSelector import modelSelector
|
|
from modules.datamodels.datamodelAi import (
|
|
AiModel,
|
|
AiModelCall,
|
|
AiModelResponse,
|
|
AiCallOptions,
|
|
OperationTypeEnum,
|
|
ProcessingModeEnum,
|
|
)
|
|
from modules.datamodels.datamodelUam import User
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class AICenterChatModel(BaseChatModel):
|
|
"""
|
|
LangChain-compatible chat model that uses AI center models.
|
|
Bridges AI center model selection and calling to LangChain's BaseChatModel interface.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
user: User,
|
|
operation_type: OperationTypeEnum = OperationTypeEnum.DATA_ANALYSE,
|
|
processing_mode: ProcessingModeEnum = ProcessingModeEnum.DETAILED,
|
|
**kwargs
|
|
):
|
|
"""
|
|
Initialize the AI center chat model bridge.
|
|
|
|
Args:
|
|
user: Current user for RBAC and model selection
|
|
operation_type: Operation type for model selection
|
|
processing_mode: Processing mode for model selection
|
|
**kwargs: Additional arguments passed to BaseChatModel
|
|
"""
|
|
super().__init__(**kwargs)
|
|
# Use object.__setattr__ to bypass Pydantic validation for custom attributes
|
|
object.__setattr__(self, "user", user)
|
|
object.__setattr__(self, "operation_type", operation_type)
|
|
object.__setattr__(self, "processing_mode", processing_mode)
|
|
object.__setattr__(self, "_selected_model", None)
|
|
|
|
@property
|
|
def _llm_type(self) -> str:
|
|
"""Return type of LLM."""
|
|
return "aicenter"
|
|
|
|
def _select_model(self, messages: List[BaseMessage]) -> AiModel:
|
|
"""
|
|
Select the best AI center model for the given messages.
|
|
|
|
Args:
|
|
messages: List of LangChain messages
|
|
|
|
Returns:
|
|
Selected AI model
|
|
"""
|
|
# Convert messages to prompt/context format for model selector
|
|
prompt_parts = []
|
|
context_parts = []
|
|
|
|
for msg in messages:
|
|
if isinstance(msg, SystemMessage):
|
|
prompt_parts.append(msg.content)
|
|
elif isinstance(msg, HumanMessage):
|
|
prompt_parts.append(msg.content)
|
|
elif isinstance(msg, AIMessage):
|
|
context_parts.append(msg.content)
|
|
elif isinstance(msg, ToolMessage):
|
|
context_parts.append(f"Tool {msg.name}: {msg.content}")
|
|
|
|
prompt = "\n".join(prompt_parts)
|
|
context = "\n".join(context_parts) if context_parts else ""
|
|
|
|
# Get available models with RBAC filtering
|
|
from modules.security.rbac import RbacClass
|
|
from modules.security.rootAccess import getRootDbAppConnector
|
|
from modules.connectors.connectorDbPostgre import DatabaseConnector
|
|
from modules.shared.configuration import APP_CONFIG
|
|
|
|
# Get database connectors for RBAC
|
|
# Create a database connector instance for RBAC with proper configuration
|
|
dbHost = APP_CONFIG.get("DB_MANAGEMENT_HOST")
|
|
dbDatabase = APP_CONFIG.get("DB_MANAGEMENT_DATABASE", "management")
|
|
dbUser = APP_CONFIG.get("DB_MANAGEMENT_USER")
|
|
dbPassword = APP_CONFIG.get("DB_MANAGEMENT_PASSWORD_SECRET")
|
|
dbPort = int(APP_CONFIG.get("DB_MANAGEMENT_PORT"))
|
|
|
|
db = DatabaseConnector(
|
|
dbHost=dbHost,
|
|
dbDatabase=dbDatabase,
|
|
dbUser=dbUser,
|
|
dbPassword=dbPassword,
|
|
dbPort=dbPort,
|
|
userId=self.user.id if hasattr(self.user, 'id') else None
|
|
)
|
|
dbApp = getRootDbAppConnector()
|
|
rbac_instance = RbacClass(db, dbApp=dbApp)
|
|
|
|
available_models = modelRegistry.getAvailableModels(
|
|
currentUser=self.user,
|
|
rbacInstance=rbac_instance
|
|
)
|
|
|
|
# Create options for model selector
|
|
options = AiCallOptions(
|
|
operationType=self.operation_type,
|
|
processingMode=self.processing_mode
|
|
)
|
|
|
|
# Select model
|
|
selected_model = modelSelector.selectModel(
|
|
prompt=prompt,
|
|
context=context,
|
|
options=options,
|
|
availableModels=available_models
|
|
)
|
|
|
|
if not selected_model:
|
|
raise ValueError(f"No suitable model found for operation type {self.operation_type.value}")
|
|
|
|
logger.info(f"Selected AI center model: {selected_model.displayName} ({selected_model.name})")
|
|
object.__setattr__(self, "_selected_model", selected_model)
|
|
return selected_model
|
|
|
|
def _convert_messages_to_ai_format(self, messages: List[BaseMessage]) -> List[Dict[str, Any]]:
|
|
"""
|
|
Convert LangChain messages to AI center format (OpenAI-style).
|
|
|
|
Args:
|
|
messages: List of LangChain messages
|
|
|
|
Returns:
|
|
List of messages in OpenAI format
|
|
"""
|
|
# Use LangChain's built-in conversion
|
|
openai_messages = convert_to_openai_messages(messages)
|
|
return openai_messages
|
|
|
|
def _convert_ai_response_to_langchain(
|
|
self,
|
|
response: AiModelResponse,
|
|
tool_calls: Optional[List[Dict[str, Any]]] = None
|
|
) -> AIMessage:
|
|
"""
|
|
Convert AI center response to LangChain AIMessage.
|
|
|
|
Args:
|
|
response: AI center response
|
|
tool_calls: Optional tool calls from the response (format: [{"id": "...", "name": "...", "args": {...}}])
|
|
|
|
Returns:
|
|
LangChain AIMessage with tool_calls if present
|
|
"""
|
|
# LangChain expects tool_calls in format: [{"id": "...", "name": "...", "args": {...}}]
|
|
# The tool_calls parameter should already be in this format
|
|
|
|
kwargs = {}
|
|
if tool_calls:
|
|
kwargs["tool_calls"] = tool_calls
|
|
|
|
return AIMessage(content=response.content or "", **kwargs)
|
|
|
|
def _generate(
|
|
self,
|
|
messages: List[BaseMessage],
|
|
stop: Optional[List[str]] = None,
|
|
run_manager: Optional[Any] = None,
|
|
**kwargs: Any,
|
|
) -> ChatResult:
|
|
"""
|
|
Synchronous generate method required by BaseChatModel.
|
|
Wraps the async _agenerate method.
|
|
|
|
Args:
|
|
messages: List of LangChain messages
|
|
stop: Optional stop sequences
|
|
run_manager: Optional callback manager
|
|
**kwargs: Additional arguments
|
|
|
|
Returns:
|
|
ChatResult with generations
|
|
"""
|
|
# Try to get the current event loop
|
|
try:
|
|
loop = asyncio.get_event_loop()
|
|
if loop.is_running():
|
|
# If we're in an async context, raise an error
|
|
raise RuntimeError(
|
|
"AICenterChatModel._generate() called from async context. "
|
|
"Use _agenerate() instead."
|
|
)
|
|
except RuntimeError:
|
|
# No event loop, we can create one
|
|
pass
|
|
|
|
# Run the async method synchronously
|
|
return asyncio.run(self._agenerate(messages, stop=stop, run_manager=run_manager, **kwargs))
|
|
|
|
async def _agenerate(
|
|
self,
|
|
messages: List[BaseMessage],
|
|
stop: Optional[List[str]] = None,
|
|
run_manager: Optional[Any] = None,
|
|
**kwargs: Any,
|
|
) -> ChatResult:
|
|
"""
|
|
Async generate method required by BaseChatModel.
|
|
|
|
Args:
|
|
messages: List of LangChain messages
|
|
stop: Optional stop sequences
|
|
run_manager: Optional callback manager
|
|
**kwargs: Additional arguments (may include tools for tool calling)
|
|
|
|
Returns:
|
|
ChatResult with generations
|
|
"""
|
|
# Select model if not already selected
|
|
if not self._selected_model:
|
|
self._select_model(messages)
|
|
|
|
# Check if tools are bound (for tool calling)
|
|
tools = getattr(self, "_bound_tools", None)
|
|
|
|
# Convert messages to AI center format
|
|
ai_messages = self._convert_messages_to_ai_format(messages)
|
|
|
|
# If tools are bound, add tool definitions to the system message
|
|
# This ensures the model knows about available tools
|
|
# Some models need explicit tool definitions to enable tool calling
|
|
if tools:
|
|
# Find or create system message
|
|
system_message_idx = None
|
|
for i, msg in enumerate(ai_messages):
|
|
if msg.get("role") == "system":
|
|
system_message_idx = i
|
|
break
|
|
|
|
# Build tool descriptions for the system message
|
|
tool_descriptions = []
|
|
for tool in tools:
|
|
if hasattr(tool, "name") and hasattr(tool, "description"):
|
|
# Get tool parameters for better description
|
|
args_schema = getattr(tool, "args_schema", None)
|
|
params_info = ""
|
|
if args_schema:
|
|
try:
|
|
if hasattr(args_schema, "model_json_schema"):
|
|
schema = args_schema.model_json_schema()
|
|
if "properties" in schema:
|
|
params = list(schema["properties"].keys())
|
|
params_info = f" (Parameter: {', '.join(params)})"
|
|
except:
|
|
pass
|
|
tool_descriptions.append(f"- {tool.name}: {tool.description}{params_info}")
|
|
|
|
if tool_descriptions:
|
|
tools_text = "\n".join(tool_descriptions)
|
|
tools_note = f"\n\n⚠️⚠️⚠️ KRITISCH - TOOL-NUTZUNG ⚠️⚠️⚠️\n\nVERFÜGBARE TOOLS:\n{tools_text}\n\nABSOLUT VERBINDLICH:\n- Du MUSST diese Tools verwenden, um Anfragen zu bearbeiten!\n- Für Status-Updates MUSST du IMMER das Tool 'send_streaming_message' verwenden!\n- VERBOTEN: Normale Text-Nachrichten für Status-Updates!\n- Du MUSST Tools aufrufen, nicht nur darüber sprechen!\n\nBeispiel FALSCH: \"Ich werde die Datenbank durchsuchen...\"\nBeispiel RICHTIG: Rufe das Tool 'send_streaming_message' mit \"Durchsuche Datenbank...\" auf!"
|
|
|
|
if system_message_idx is not None:
|
|
# Append to existing system message
|
|
ai_messages[system_message_idx]["content"] += tools_note
|
|
else:
|
|
# Add new system message at the beginning
|
|
ai_messages.insert(0, {
|
|
"role": "system",
|
|
"content": tools_note.strip()
|
|
})
|
|
|
|
# Convert LangChain tools to OpenAI tool format for potential use
|
|
# Note: The actual tool calling is handled by the connector if it supports it
|
|
# This conversion is kept for potential future use or connector support
|
|
openai_tools = None
|
|
if tools and self._selected_model.connectorType == "openai":
|
|
# Convert LangChain tools to OpenAI tool format
|
|
openai_tools = []
|
|
for tool in tools:
|
|
if hasattr(tool, "name") and hasattr(tool, "description"):
|
|
# Get tool parameters schema
|
|
args_schema = getattr(tool, "args_schema", None)
|
|
parameters = {}
|
|
if args_schema:
|
|
# Check if it's a Pydantic model class or instance
|
|
from pydantic import BaseModel
|
|
|
|
# Check if it's a class (not an instance)
|
|
if isinstance(args_schema, type) and issubclass(args_schema, BaseModel):
|
|
# It's a Pydantic model class - get JSON schema
|
|
if hasattr(args_schema, "model_json_schema"):
|
|
# Pydantic v2
|
|
parameters = args_schema.model_json_schema()
|
|
elif hasattr(args_schema, "schema"):
|
|
# Pydantic v1
|
|
parameters = args_schema.schema()
|
|
elif isinstance(args_schema, BaseModel):
|
|
# It's a Pydantic model instance
|
|
if hasattr(args_schema, "model_dump"):
|
|
# Pydantic v2
|
|
parameters = args_schema.model_dump()
|
|
elif hasattr(args_schema, "dict"):
|
|
# Pydantic v1
|
|
parameters = args_schema.dict()
|
|
elif hasattr(args_schema, "schema"):
|
|
# Has schema method (might be a class)
|
|
try:
|
|
parameters = args_schema.schema()
|
|
except TypeError:
|
|
# If schema() requires instance, try model_json_schema
|
|
if hasattr(args_schema, "model_json_schema"):
|
|
parameters = args_schema.model_json_schema()
|
|
else:
|
|
parameters = {}
|
|
elif isinstance(args_schema, dict):
|
|
# Already a dict
|
|
parameters = args_schema
|
|
|
|
tool_schema = {
|
|
"type": "function",
|
|
"function": {
|
|
"name": tool.name,
|
|
"description": tool.description or "",
|
|
"parameters": parameters
|
|
}
|
|
}
|
|
openai_tools.append(tool_schema)
|
|
|
|
# Store tools for potential use by connector
|
|
# Note: The connector may need to access tools from the model_call
|
|
# This is a workaround since AiModelCall doesn't have a tools field
|
|
# Tools are added to system message above to ensure model knows about them
|
|
|
|
# Create model call
|
|
model_call = AiModelCall(
|
|
messages=ai_messages,
|
|
model=self._selected_model,
|
|
options=AiCallOptions(
|
|
operationType=self.operation_type,
|
|
processingMode=self.processing_mode,
|
|
temperature=self._selected_model.temperature
|
|
)
|
|
)
|
|
|
|
# If tools are bound and this is an OpenAI model, we need to call the API directly
|
|
# with tools included, since the connector interface doesn't support tools
|
|
if openai_tools and self._selected_model.connectorType == "openai":
|
|
# Call OpenAI API directly with tools (like legacy ChatAnthropic does)
|
|
import httpx
|
|
from modules.shared.configuration import APP_CONFIG
|
|
|
|
api_key = APP_CONFIG.get('Connector_AiOpenai_API_SECRET')
|
|
if not api_key:
|
|
raise ValueError("OpenAI API key not configured")
|
|
|
|
payload = {
|
|
"model": self._selected_model.name,
|
|
"messages": ai_messages,
|
|
"tools": openai_tools,
|
|
"tool_choice": "auto", # Let model decide when to use tools
|
|
"temperature": self._selected_model.temperature,
|
|
"max_tokens": self._selected_model.maxTokens
|
|
}
|
|
|
|
async with httpx.AsyncClient(timeout=600.0) as client:
|
|
response_obj = await client.post(
|
|
self._selected_model.apiUrl,
|
|
headers={
|
|
"Authorization": f"Bearer {api_key}",
|
|
"Content-Type": "application/json"
|
|
},
|
|
json=payload
|
|
)
|
|
|
|
if response_obj.status_code != 200:
|
|
error_msg = f"OpenAI API error: {response_obj.status_code} - {response_obj.text}"
|
|
logger.error(error_msg)
|
|
raise ValueError(error_msg)
|
|
|
|
response_json = response_obj.json()
|
|
choice = response_json["choices"][0]
|
|
message = choice["message"]
|
|
|
|
# Extract content and tool calls
|
|
content = message.get("content", "")
|
|
tool_calls_raw = message.get("tool_calls")
|
|
|
|
# Convert OpenAI tool_calls format to LangChain format
|
|
# LangChain expects: [{"id": "...", "name": "...", "args": {...}}]
|
|
tool_calls = None
|
|
if tool_calls_raw:
|
|
tool_calls = []
|
|
for tc in tool_calls_raw:
|
|
func_data = tc.get("function", {})
|
|
func_name = func_data.get("name")
|
|
func_args_str = func_data.get("arguments", "{}")
|
|
|
|
# Parse JSON arguments string to dict
|
|
import json
|
|
try:
|
|
func_args = json.loads(func_args_str) if isinstance(func_args_str, str) else func_args_str
|
|
except:
|
|
func_args = {}
|
|
|
|
tool_calls.append({
|
|
"id": tc.get("id"),
|
|
"name": func_name,
|
|
"args": func_args
|
|
})
|
|
|
|
# Create response object
|
|
response = AiModelResponse(
|
|
content=content or "",
|
|
success=True,
|
|
modelId=self._selected_model.name,
|
|
metadata={
|
|
"response_id": response_json.get("id", ""),
|
|
"tool_calls": tool_calls
|
|
}
|
|
)
|
|
else:
|
|
# No tools or not OpenAI - use connector normally
|
|
if not self._selected_model.functionCall:
|
|
raise ValueError(f"Model {self._selected_model.displayName} has no functionCall defined")
|
|
|
|
response: AiModelResponse = await self._selected_model.functionCall(model_call)
|
|
|
|
if not response.success:
|
|
raise ValueError(f"AI model call failed: {response.error or 'Unknown error'}")
|
|
|
|
# Extract tool calls from response metadata if present
|
|
tool_calls = None
|
|
if response.metadata:
|
|
# Check for tool calls in metadata (format may vary by connector)
|
|
tool_calls = response.metadata.get("tool_calls") or response.metadata.get("function_calls")
|
|
|
|
# Convert response to LangChain format with tool calls
|
|
ai_message = self._convert_ai_response_to_langchain(response, tool_calls=tool_calls)
|
|
|
|
# Create generation and result
|
|
generation = ChatGeneration(message=ai_message)
|
|
return ChatResult(generations=[generation])
|
|
|
|
def bind_tools(self, tools: List[Any], **kwargs: Any) -> "AICenterChatModel":
|
|
"""
|
|
Bind tools to the model (required for LangGraph tool calling).
|
|
|
|
Args:
|
|
tools: List of LangChain tools
|
|
**kwargs: Additional arguments
|
|
|
|
Returns:
|
|
New instance with tools bound
|
|
"""
|
|
# Create a new instance with tools bound
|
|
# Note: The actual tool binding happens in LangGraph's ToolNode
|
|
# This method is called by LangGraph to prepare the model
|
|
bound_model = AICenterChatModel(
|
|
user=self.user,
|
|
operation_type=self.operation_type,
|
|
processing_mode=self.processing_mode
|
|
)
|
|
object.__setattr__(bound_model, "_selected_model", self._selected_model)
|
|
# Store tools for potential use in message conversion
|
|
object.__setattr__(bound_model, "_bound_tools", tools)
|
|
return bound_model
|
|
|
|
def invoke(
|
|
self,
|
|
input: List[BaseMessage],
|
|
config: Optional[RunnableConfig] = None,
|
|
**kwargs: Any,
|
|
) -> BaseMessage:
|
|
"""
|
|
Synchronous invoke method (required by BaseChatModel).
|
|
Note: This is a wrapper around async _agenerate.
|
|
|
|
Args:
|
|
input: List of LangChain messages
|
|
config: Optional runnable config
|
|
**kwargs: Additional arguments
|
|
|
|
Returns:
|
|
AIMessage response
|
|
"""
|
|
import asyncio
|
|
|
|
# Try to get existing event loop
|
|
try:
|
|
loop = asyncio.get_event_loop()
|
|
if loop.is_running():
|
|
# If loop is running, we need to use a different approach
|
|
# This shouldn't happen in LangGraph context, but handle it gracefully
|
|
raise RuntimeError("Cannot use synchronous invoke in async context. Use ainvoke instead.")
|
|
except RuntimeError:
|
|
loop = asyncio.new_event_loop()
|
|
asyncio.set_event_loop(loop)
|
|
|
|
# Run async generation
|
|
result = loop.run_until_complete(self._agenerate(input, **kwargs))
|
|
return result.generations[0].message
|
|
|
|
async def ainvoke(
|
|
self,
|
|
input: List[BaseMessage],
|
|
config: Optional[RunnableConfig] = None,
|
|
**kwargs: Any,
|
|
) -> BaseMessage:
|
|
"""
|
|
Async invoke method (required by BaseChatModel).
|
|
|
|
Args:
|
|
input: List of LangChain messages
|
|
config: Optional runnable config
|
|
**kwargs: Additional arguments
|
|
|
|
Returns:
|
|
AIMessage response
|
|
"""
|
|
result = await self._agenerate(input, **kwargs)
|
|
return result.generations[0].message
|