A-mem/agentic_memory/llm_controller.py

import os
from abc import ABC, abstractmethod
from typing import Any, Dict, Literal, Optional

from .dashscope_adapters import CallLogger, DashScopeChatAdapter


class BaseLLMController(ABC):
    @abstractmethod
    def get_completion(
        self,
        prompt: str,
        response_format: Optional[Dict[str, Any]] = None,
        temperature: float = 0.7,
    ) -> str:
        """Get completion from an LLM backend."""

    def set_call_context(self, **context: Any) -> None:
        """Optional hook for request-scoped logging metadata."""


class OpenAIController(BaseLLMController):
    def __init__(
        self,
        model: str = "gpt-4o-mini",
        api_key: Optional[str] = None,
        base_url: Optional[str] = None,
        call_logger: Optional[CallLogger] = None,
    ):
        try:
            from openai import OpenAI
        except ImportError as exc:  # pragma: no cover - environment dependent
            raise ImportError("OpenAI package not found. Install it with: pip install openai") from exc

        resolved_api_key = api_key or os.getenv("OPENAI_API_KEY")
        if resolved_api_key is None:
            raise ValueError("OpenAI API key not found. Set OPENAI_API_KEY.")

        self.model = model
        self.client = OpenAI(api_key=resolved_api_key, base_url=base_url, max_retries=0)
        self.call_logger = call_logger
        self._next_context: Dict[str, Any] = {}

    def set_call_context(self, **context: Any) -> None:
        self._next_context = dict(context)

    def get_completion(
        self,
        prompt: str,
        response_format: Optional[Dict[str, Any]] = None,
        temperature: float = 0.7,
    ) -> str:
        kwargs: Dict[str, Any] = {
            "model": self.model,
            "messages": [
                {"role": "system", "content": "You must respond with a JSON object."},
                {"role": "user", "content": prompt},
            ],
            "temperature": temperature,
            "max_tokens": 1000,
        }
        if response_format is not None:
            kwargs["response_format"] = response_format

        response = self.client.chat.completions.create(**kwargs)
        return response.choices[0].message.content or ""


class DashScopeController(BaseLLMController):
    def __init__(
        self,
        model: str = "qwen3-max-2026-01-23",
        api_key: Optional[str] = None,
        base_url: str = "https://dashscope.aliyuncs.com/compatible-mode/v1",
        call_logger: Optional[CallLogger] = None,
    ):
        self.adapter = DashScopeChatAdapter(
            model=model,
            api_key=api_key,
            base_url=base_url,
            call_logger=call_logger,
        )

    def set_call_context(self, **context: Any) -> None:
        self.adapter.set_call_context(**context)

    def get_completion(
        self,
        prompt: str,
        response_format: Optional[Dict[str, Any]] = None,
        temperature: float = 0.7,
    ) -> str:
        return self.adapter.get_completion(
            prompt=prompt,
            response_format=response_format,
            temperature=temperature,
        )


class OllamaController(BaseLLMController):
    def __init__(self, model: str = "llama2"):
        try:
            from openai import OpenAI
        except ImportError as exc:  # pragma: no cover - environment dependent
            raise ImportError("OpenAI package not found. Install it with: pip install openai") from exc

        self.model = model
        self.client = OpenAI(api_key="ollama", base_url="http://localhost:11434/v1", max_retries=0)

    def get_completion(
        self,
        prompt: str,
        response_format: Optional[Dict[str, Any]] = None,
        temperature: float = 0.7,
    ) -> str:
        kwargs: Dict[str, Any] = {
            "model": self.model,
            "messages": [
                {"role": "system", "content": "You must respond with a JSON object."},
                {"role": "user", "content": prompt},
            ],
            "temperature": temperature,
            "max_tokens": 1000,
        }
        if response_format is not None:
            kwargs["response_format"] = response_format
        response = self.client.chat.completions.create(**kwargs)
        return response.choices[0].message.content or ""


class LLMController:
    """LLM-based controller for memory metadata generation."""

    def __init__(
        self,
        backend: Literal["openai", "ollama", "dashscope"] = "openai",
        model: str = "gpt-4o-mini",
        api_key: Optional[str] = None,
        base_url: Optional[str] = None,
        call_logger: Optional[CallLogger] = None,
    ):
        if backend == "openai":
            self.llm = OpenAIController(model, api_key, base_url, call_logger)
        elif backend == "ollama":
            self.llm = OllamaController(model)
        elif backend == "dashscope":
            self.llm = DashScopeController(
                model=model,
                api_key=api_key,
                base_url=base_url or "https://dashscope.aliyuncs.com/compatible-mode/v1",
                call_logger=call_logger,
            )
        else:
            raise ValueError("Backend must be one of: 'openai', 'ollama', 'dashscope'")

    def set_call_context(self, **context: Any) -> None:
        if hasattr(self.llm, "set_call_context"):
            self.llm.set_call_context(**context)

    def get_completion(
        self,
        prompt: str,
        response_format: Optional[Dict[str, Any]] = None,
        temperature: float = 0.7,
    ) -> str:
        return self.llm.get_completion(prompt, response_format, temperature)