naas-abi-core 1.4.1__py3-none-any.whl

naas_abi_core/services/agent/IntentAgent_test.py

@@ -0,0 +1,139 @@
+import pytest
+from langchain_openai import ChatOpenAI
+from naas_abi_core.services.agent.IntentAgent import (
+    Agent,
+    AgentConfiguration,
+    Intent,
+    IntentAgent,
+    IntentType,
+)
+
+
+@pytest.fixture
+def agent():
+    model = ChatOpenAI(model="gpt-4.1")
+    subagent_chatgpt = Agent(
+        name="ChatGPT",
+        description="ChatGPT agent",
+        chat_model=model,
+        tools=[],
+        agents=[],
+        configuration=AgentConfiguration(),
+    )
+    subagent_perplexity = Agent(
+        name="Perplexity",
+        description="Perplexity agent",
+        chat_model=model,
+        tools=[],
+        agents=[],
+        configuration=AgentConfiguration(),
+    )
+
+    intents = [
+        Intent(
+            intent_value="test",
+            intent_type=IntentType.RAW,
+            intent_target="This is a test intent",
+        ),
+        Intent(
+            intent_value="Give me the personal phone number of John Doe",
+            intent_type=IntentType.RAW,
+            intent_target="I can't give you the personal phone number of John Doe",
+        ),
+        Intent(
+            intent_value="Give me the professional phone number of John Doe",
+            intent_type=IntentType.RAW,
+            intent_target="00 11 22 33 44 55",
+        ),
+        Intent(
+            intent_value="a phone number of",
+            intent_type=IntentType.RAW,
+            intent_target="What phone number do you want?",
+        ),
+        Intent(
+            intent_value="What is the color of the shoes of Tom?",
+            intent_type=IntentType.RAW,
+            intent_target="The color of the shoes of Tom is red",
+        ),
+        Intent(
+            intent_value="Search news about",
+            intent_type=IntentType.AGENT,
+            intent_target="ChatGPT",
+        ),
+        Intent(
+            intent_value="Search news about",
+            intent_type=IntentType.AGENT,
+            intent_target="Perplexity",
+        ),
+    ]
+
+    agent = IntentAgent(
+        name="Test Agent",
+        description="A test agent",
+        chat_model=model,
+        tools=[],
+        agents=[subagent_chatgpt, subagent_perplexity],
+        intents=intents,
+        configuration=AgentConfiguration(system_prompt="You are an helpful assistant."),
+    )
+    return agent
+
+
+def test_intent_agent(agent):
+    test = agent.invoke("test")
+    assert test == "This is a test intent", test
+
+    result = agent.invoke("professional phone number of John Doe")
+    assert "00 11 22 33 44 55" == result, result
+
+    result = agent.invoke("personal phone number of John Doe")
+    assert (
+        "I can't give you the personal phone number of John Doe".lower()
+        in result.lower()
+    ), result
+    assert (
+        len(agent._intent_mapper.map_intent("Give me the professional phone number of"))
+        == 1
+    ), agent._intent_mapper.map_intent("Give me the professional phone number of")
+
+    result = agent.invoke("Give me the professional phone number of")
+    assert "00 11 22 33 44 55".lower() not in result.lower(), result
+
+
+def test_direct_intent(agent):
+    result = agent.invoke("Hello")
+    assert "Hello, what can I do for you?" == result, result
+
+    result = agent.invoke("Thank you")
+    assert "You're welcome, can I help you with anything else?" == result, result
+
+
+def test_request_human_validation(agent):
+    result = agent.invoke("Search news about ai")
+
+    assert result is not None, result
+    assert "I found multiple intents that could handle your request" in result, result
+    assert "chatgpt" in result.lower() or "perplexity" in result.lower(), result
+
+
+def test_request_help_tool(agent):
+    """Test AGENT intent mapping for chatgpt"""
+    result = agent.invoke("@Knowledge_Graph_Builder hello")
+
+    # Knowledge_Graph_Builder: Hello, what can I do for you?
+
+    assert result is not None, result
+    assert "Hello, what can I do for you?" in result, result
+
+    result = agent.invoke("search news about ai")  # testing routing to other agents
+
+    # Knowledge_Graph_Builder: I found multiple intents that could handle your request:
+
+    #  1 ChatGPT (confidence: 89.7%) Intent: search news about
+    #  2 Grok (confidence: 89.7%) Intent: search news about
+
+    # Please choose an intent by number (e.g., '1' or '2')
+
+    assert result is not None, result
+    assert "I found multiple intents that could handle your request" in result, result
+    assert "chatgpt" in result.lower() or "grok" in result.lower(), result

naas_abi_core/services/agent/beta/Embeddings.py

@@ -0,0 +1,181 @@
+import hashlib
+import os
+
+import requests
+
+# from dotenv import load_dotenv
+from naas_abi_core.services.cache.CacheFactory import CacheFactory
+from naas_abi_core.services.cache.CachePort import DataType
+from pydantic import SecretStr
+from tqdm import tqdm
+
+# load_dotenv()
+
+
+cache = CacheFactory.CacheFS_find_storage(subpath="intent_mapping")
+
+EMBEDDINGS_MODELS_DIMENSIONS_MAP: dict[str, int] = {
+    "ai/embeddinggemma": 768,
+    "text-embedding-ada-002": 1536,
+    "text-embedding-3-small": 1536,
+    "text-embedding-3-large": 3072,
+    "openai/text-embedding-3-large": 3072,
+}
+
+
+def __get_safe_model(model: str):
+    """
+    Returns a sanitized version of the model name suitable for use in cache keys.
+
+    Args:
+        model (str): The model name to sanitize.
+
+    Returns:
+        str: The sanitized model name.
+
+    Raises:
+        AssertionError: If the model is not in the EMBEDDINGS_MODELS_DIMENSIONS_MAP.
+    """
+    assert model in EMBEDDINGS_MODELS_DIMENSIONS_MAP, (
+        f"Model {model} not supported. You need to add it to the EMBEDDINGS_MODELS_DIMENSIONS_MAP in Embeddings.py"
+    )
+    return "".join([c if c.isalnum() or c in ("-", "_") else "_" for c in model])
+
+
+def __compute_key(safe_model: str, dimensions: int, text: str):
+    """
+    Computes a unique cache key for a given model and text.
+
+    Args:
+        safe_model (str): The sanitized model name.
+        text (str): The input text.
+
+    Returns:
+        str: The computed cache key.
+    """
+    return f"{safe_model}_{dimensions}_{hashlib.sha1(text.encode('utf-8')).hexdigest()}"
+
+
+def _sha1s(model: str):
+    """
+    Returns a function that computes a combined cache key for a list of texts for a given model.
+
+    Args:
+        model (str): The model name.
+
+    Returns:
+        Callable[[list[str]], str]: A function that takes a list of texts and returns a combined cache key.
+    """
+    safe_model = __get_safe_model(model)
+
+    def func(texts):
+        """
+        Computes a combined cache key for a list of texts.
+
+        Args:
+            texts (list[str]): The list of input texts.
+
+        Returns:
+            str: The combined cache key.
+        """
+        key = ""
+        for text in texts:
+            key += __compute_key(
+                safe_model, EMBEDDINGS_MODELS_DIMENSIONS_MAP[model], text
+            )
+        return key
+
+    return func
+
+
+def _sha1(model: str):
+    """
+    Returns a function that computes a cache key for a single text for a given model.
+
+    Args:
+        model (str): The model name.
+
+    Returns:
+        Callable[[str], str]: A function that takes a text and returns a cache key.
+    """
+    safe_model = __get_safe_model(model)
+
+    def func(text):
+        """
+        Computes a cache key for a single text.
+
+        Args:
+            text (str): The input text.
+
+        Returns:
+            str: The cache key.
+        """
+        return __compute_key(safe_model, EMBEDDINGS_MODELS_DIMENSIONS_MAP[model], text)
+
+    return func
+
+
+_model_name: str | None = None
+
+if os.environ.get("AI_MODE") == "airgap":
+    _model_name = "ai/embeddinggemma"
+
+    @cache(_sha1(_model_name), cache_type=DataType.PICKLE)
+    def embeddings(text) -> list[float]:
+        res = requests.post(
+            "http://localhost:12434/engines/llama.cpp/v1/embeddings",
+            json={"model": _model_name, "input": text},
+        )
+        res.raise_for_status()
+        return res.json()["data"][0]["embedding"]
+
+    @cache(_sha1s(_model_name), cache_type=DataType.PICKLE)
+    def embeddings_batch(texts) -> list[list[float]]:
+        ret = []
+
+        for text in tqdm(texts, "Embedding intents"):
+            ret.append(embeddings(text))
+
+        return ret
+
+else:
+    from langchain_openai import OpenAIEmbeddings
+
+    # Lazy initialization to avoid import-time API key requirement
+    _embeddings_model = None
+    _model_name = "text-embedding-ada-002"
+
+    api_key_value = os.getenv("OPENROUTER_API_KEY")
+    api_key = SecretStr(api_key_value) if api_key_value else None
+    if api_key_value:
+        _model_name = "openai/text-embedding-3-large"
+
+    def _get_embeddings_model():
+        global _embeddings_model
+        if _embeddings_model is None and api_key is None:
+            _embeddings_model = OpenAIEmbeddings(model=_model_name)
+        elif _embeddings_model is None and api_key:
+            _embeddings_model = OpenAIEmbeddings(
+                model=_model_name,
+                api_key=api_key,
+                base_url="https://openrouter.ai/api/v1",
+            )
+        return _embeddings_model
+
+    @cache(_sha1s(_model_name), cache_type=DataType.PICKLE)
+    def embeddings_batch(texts):
+        for e in tqdm([texts], "Embedding intents"):
+            return _get_embeddings_model().embed_documents(e)
+
+    @cache(_sha1(_model_name), cache_type=DataType.PICKLE)
+    def embeddings(text):
+        """Generate embeddings for text using OpenAI's embedding model.
+
+        Args:
+            text (str): The text to generate embeddings for
+
+        Returns:
+            List[float]: The embedding vector
+        """
+
+        return _get_embeddings_model().embed_query(text)

naas_abi_core/services/agent/beta/IntentMapper.py

@@ -0,0 +1,120 @@
+import os
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Optional, Tuple
+
+# from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from pydantic import SecretStr
+
+from .Embeddings import EMBEDDINGS_MODELS_DIMENSIONS_MAP
+from .Embeddings import _model_name as embeddings_model_name
+from .Embeddings import embeddings as embeddings
+from .Embeddings import embeddings_batch
+from .VectorStore import VectorStore
+
+# load_dotenv()
+
+
+class IntentScope(Enum):
+    DIRECT = "direct"
+    ALL = "all"
+
+
+class IntentType(Enum):
+    AGENT = "agent"
+    TOOL = "tool"
+    RAW = "raw"
+
+
+@dataclass
+class Intent:
+    intent_value: str
+    intent_type: IntentType
+    intent_target: Any
+    intent_scope: Optional[IntentScope] = IntentScope.ALL
+
+
+class IntentMapper:
+    intents: list[Intent]
+    vector_store: VectorStore
+    model: ChatOpenAI
+    system_prompt: str
+
+    def __init__(self, intents: list[Intent]):
+        self.intents = intents
+
+        # Use environment-based detection for consistent embedding source
+        if embeddings_model_name is not None:
+            dimension: int = EMBEDDINGS_MODELS_DIMENSIONS_MAP.get(
+                embeddings_model_name, 1536
+            )
+        else:
+            raise ValueError("Embeddings model name is not set")
+
+        self.vector_store = VectorStore(dimension=dimension)
+        intents_values = [intent.intent_value for intent in intents]
+        metadatas = [{"index": index} for index in range(len(intents_values))]
+        self.vector_store.add_texts(
+            intents_values,
+            embeddings=embeddings_batch(intents_values),
+            metadatas=metadatas,
+        )
+
+        api_key_value = os.getenv("OPENROUTER_API_KEY")
+        api_key = SecretStr(api_key_value) if api_key_value else None
+
+        # Detect if we're using local embeddings (768 dim = airgap mode)
+        if os.getenv("AI_MODE") == "airgap":
+            from naas_abi_core.services.agent.beta.LocalModel import AirgapChatOpenAI
+
+            self.model = AirgapChatOpenAI(
+                model="ai/gemma3",
+                temperature=0.7,
+                base_url="http://localhost:12434/engines/v1",
+                api_key="ignored",
+            )
+        # Detect if we're using OpenRouter
+        elif api_key:
+            self.model = ChatOpenAI(
+                model="gpt-4.1-mini",
+                api_key=api_key,
+                base_url="https://openrouter.ai/api/v1",
+            )
+        # Fallback to OpenAI
+        else:
+            self.model = ChatOpenAI(model="gpt-4.1-mini")
+
+        # Set the system prompt
+        self.system_prompt = """
+You are an intent mapper. The user will send you a prompt and you should output the intent and the intent only. If the user references a technology, you must have the name of the technology in the intent.
+
+Example:
+User: 3 / 4 + 5
+You: calculate an arithmetic result
+
+User: I need to write a report about the latest trends in AI.
+You: write a report
+
+User: I need to code a project.
+You: code a project
+"""
+
+    def get_intent_from_value(self, value: str) -> Intent | None:
+        for intent in self.intents:
+            if intent.intent_value == value:
+                return intent
+        return None
+
+    def map_intent(self, intent: str, k: int = 1) -> list[dict]:
+        results = self.vector_store.similarity_search(embeddings(intent), k=k)
+        for result in results:
+            result["intent"] = self.intents[result["metadata"]["index"]]
+
+        return results
+
+    def map_prompt(self, prompt: str, k: int = 1) -> Tuple[list[dict], list[dict]]:
+        # Use direct prompt mapping without LLM intent extraction for speed
+        # Return empty first result and prompt results as second (matches expected format)
+        prompt_results = self.map_intent(prompt, k)
+        return [], prompt_results

naas_abi_core/services/agent/beta/LocalModel.py

@@ -0,0 +1,88 @@
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import BaseMessage, HumanMessage
+from langchain_core.outputs import ChatResult
+from langchain_core.callbacks.manager import CallbackManagerForLLMRun
+from typing import Optional, List, Any
+import json
+import re
+
+class AirgapChatOpenAI(ChatOpenAI):
+    """Minimal wrapper for Docker Model Runner with basic tool support"""
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._tools = []
+    
+    def bind_tools(self, tools, **kwargs):
+        self._tools = tools
+        return self
+    
+    def bind(self, **kwargs):
+        # Strip tool parameters that Docker Model Runner doesn't support
+        clean_kwargs = {k: v for k, v in kwargs.items() if 'tool' not in k.lower()}
+        return super().bind(**clean_kwargs) if clean_kwargs else self
+    
+    def _generate(self, messages: List[BaseMessage], stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any) -> ChatResult:
+        # Extract system prompt and user message
+        system_prompt = ""
+        user_msg = None
+        
+        for msg in messages:
+            if hasattr(msg, 'content'):
+                if 'SystemMessage' in str(type(msg)):
+                    if isinstance(msg.content, str):
+                        system_prompt += msg.content + "\n"
+                elif isinstance(msg, HumanMessage):
+                    user_msg = msg.content
+        
+        if user_msg:
+            # Build complete prompt with system context
+            prompt = system_prompt.strip()
+            
+            if self._tools:
+                # Add tool info
+                tool_info = "\nAvailable tools:\n"
+                for tool in self._tools:
+                    if hasattr(tool, 'name') and hasattr(tool, 'description'):
+                        tool_info += f"- {tool.name}: {tool.description}\n"
+                tool_info += "\nTo use a tool, respond with: TOOL_CALL: tool_name {json_args}\n"
+                prompt += tool_info
+            
+            prompt += f"\n\nUser: {user_msg}"
+            messages = [HumanMessage(content=prompt)]
+        
+        # Clean kwargs
+        clean_kwargs = {k: v for k, v in kwargs.items() if k in ['temperature', 'max_tokens', 'stop']}
+        
+        # Get response
+        result = super()._generate(messages, stop=stop, run_manager=run_manager, **clean_kwargs)
+        
+        # Handle tool calls if present
+        if self._tools and result.generations:
+            content = result.generations[0].message.content
+            if isinstance(content, str):
+                tool_calls = re.findall(r'TOOL_CALL:\s*(\w+)\s*({.*?})', content, re.DOTALL)
+            else:
+                tool_calls = []
+            
+            if tool_calls:
+                tool_results = []
+                for tool_name, args_json in tool_calls:
+                    try:
+                        args = json.loads(args_json)
+                        tool = next((t for t in self._tools if hasattr(t, 'name') and t.name == tool_name), None)
+                        if tool:
+                            if hasattr(tool, 'invoke'):
+                                result_text = tool.invoke(args)
+                            else:
+                                result_text = str(tool(**args))
+                            tool_results.append(f"{tool_name}: {result_text}")
+                    except Exception as e:
+                        tool_results.append(f"{tool_name}: Error - {e}")
+                
+                if tool_results:
+                    # Get final response with tool results
+                    final_prompt = f"{content}\n\nTool results:\n" + "\n".join(tool_results) + "\n\nProvide a final response:"
+                    result = super()._generate([HumanMessage(content=final_prompt)], stop=stop, run_manager=run_manager, **clean_kwargs)
+        
+        return result

naas_abi_core/services/agent/beta/VectorStore.py

@@ -0,0 +1,89 @@
+class VectorStore:
+    def __init__(self, dimension=1536):
+        """Initialize an in-memory vector store using Qdrant.
+        
+        Args:
+            dimension (int): The dimension of the vectors to be stored.
+        """
+        try:
+            from qdrant_client import QdrantClient
+            from qdrant_client.http import models
+        except ImportError:
+            raise ImportError("Please install qdrant-client: pip install qdrant-client")
+        
+        self.client = QdrantClient(":memory:")  # In-memory Qdrant instance
+        self.collection_name = "documents"
+        self.dimension = dimension
+        
+        # Create collection
+        self.client.create_collection(
+            collection_name=self.collection_name,
+            vectors_config=models.VectorParams(
+                size=self.dimension,
+                distance=models.Distance.COSINE
+            )
+        )
+        self.next_id = 0
+    
+    def add_texts(self, texts, metadatas=None, embeddings=None):
+        """Add texts to the vector store.
+        
+        Args:
+            texts (List[str]): List of text strings to add
+            metadatas (List[dict], optional): Metadata for each text
+            embeddings (List[List[float]], optional): Pre-computed embeddings for each text
+            
+        Returns:
+            List[str]: IDs of the added texts
+        """
+        from qdrant_client.http import models
+        
+        if embeddings is None:
+            raise ValueError("Embeddings must be provided")
+        
+        if metadatas is None:
+            metadatas = [{} for _ in texts]
+        
+        ids = list(range(self.next_id, self.next_id + len(texts)))
+        self.next_id += len(texts)
+        
+        points = [
+            models.PointStruct(
+                id=idx,
+                vector=embedding,
+                payload={"text": text, **metadata}
+            )
+            for idx, text, metadata, embedding in zip(ids, texts, metadatas, embeddings)
+        ]
+        
+        self.client.upsert(
+            collection_name=self.collection_name,
+            points=points
+        )
+        
+        return [str(idx) for idx in ids]
+    
+    def similarity_search(self, query_embedding, k=4):
+        """Search for similar documents using a query embedding.
+        
+        Args:
+            query_embedding (List[float]): The embedding vector to search with
+            k (int): Number of results to return
+            
+        Returns:
+            List[dict]: List of documents with their metadata
+        """
+        results = self.client.query_points(
+            collection_name=self.collection_name,
+            query=query_embedding,
+            limit=k
+        )
+        
+        return [
+            {
+                "text": hit.payload.get("text", ""),
+                "metadata": {k: v for k, v in hit.payload.items() if k != "text"},
+                "score": hit.score
+            }
+            for hit in results.points
+        ]