Skip to content

BrainAPI is a knowledge graph–powered AI memory layer that transforms unstructured data into structured knowledge, enabling intelligent search, recommendations, and contextual memory for AI agents and applications.

3.3 KB
Raw Blame
import json
import os
import threading
from typing import Any

from langchain_openai import ChatOpenAI
from openai import OpenAI

from src.adapters.interfaces.llm import LLM
from src.config import config

_THINKING_DISABLED = {"thinking": {"type": "disabled"}}


def _deepseek_client_kwargs() -> dict[str, Any]:
    return {
        "api_key": config.deepseek.api_key,
        "base_url": config.deepseek.base_url,
        "timeout": 120.0,
        "max_retries": 3,
    }


class _DeepSeekLLMBase(LLM):
    def __init__(self, model: str):
        self.model = model
        self._client: OpenAI | None = None
        self._langchain_model: ChatOpenAI | None = None
        self._lock = threading.Lock()
        self._pid = os.getpid()

    def _check_fork(self) -> None:
        if os.getpid() != self._pid:
            self._client = None
            self._langchain_model = None
            self._pid = os.getpid()

    @property
    def client(self) -> OpenAI:
        self._check_fork()
        if self._client is None:
            with self._lock:
                if self._client is None:
                    self._client = OpenAI(**_deepseek_client_kwargs())
        return self._client

    @property
    def langchain_model(self) -> ChatOpenAI:
        self._check_fork()
        if self._langchain_model is None:
            with self._lock:
                if self._langchain_model is None:
                    self._langchain_model = ChatOpenAI(
                        model=self.model,
                        **_deepseek_client_kwargs(),
                        extra_body=_THINKING_DISABLED,
                    )
        return self._langchain_model

    def generate_text(self, prompt: str, max_new_tokens: int = None) -> str:
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
            **({"max_tokens": max_new_tokens} if max_new_tokens else {}),
            extra_body=_THINKING_DISABLED,
        )
        return response.choices[0].message.content

    def generate_json(
        self, prompt: str, max_new_tokens: int = None, max_retries: int = 3
    ) -> dict:
        response = None
        while max_retries > 0 and response is None:
            try:
                _response = self.client.chat.completions.create(
                    model=self.model,
                    messages=[{"role": "user", "content": prompt}],
                    **({"max_tokens": max_new_tokens} if max_new_tokens else {}),
                    response_format={"type": "json_object"},
                    extra_body=_THINKING_DISABLED,
                )
                _response = (
                    _response.choices[0].message.content.strip("```json").strip("```")
                )
                response = json.loads(_response)
            except Exception as e:
                max_retries -= 1
                if max_retries <= 0:
                    raise e
        return response


class DeepSeekLLMClientSmall(_DeepSeekLLMBase):
    def __init__(self):
        super().__init__(config.deepseek.small_llm_model)


class DeepSeekLLMClientLarge(_DeepSeekLLMBase):
    def __init__(self):
        super().__init__(config.deepseek.large_llm_model)


_llm_small_client_deepseek = DeepSeekLLMClientSmall()
_llm_large_client_deepseek = DeepSeekLLMClientLarge()