API-интерфейс модели

Введение

В этом документе подробно описаны интерфейсы и структуры данных, необходимые для реализации плагинов моделей Интеллос. Он служит техническим справочником для разработчиков, интегрирующих ИИ-модели с платформой Интеллос.

Прежде чем переходить к этому справочнику по API, рекомендуем прочитать Правила проектирования моделей, чтобы понять концептуальную модель, и Создание нового поставщика модели — пошаговое руководство.

Быстрое решение: какой метод реализовывать?

Если ваша модель — это…	Реализуйте
Чат- или completion-LLM	`LargeLanguageModel._invoke`, `_get_num_tokens`
Эмбеддинг-модель	`TextEmbeddingModel._invoke`, `_get_num_tokens`
Реранк-модель	`RerankModel._invoke`
Распознавание речи	`Speech2TextModel._invoke`
Синтез речи	`Text2SpeechModel._invoke`
Модерация	`ModerationModel._invoke`

Каждый поставщик также реализует validate_provider_credentials (аутентификация на уровне поставщика) и, если модель настраивается пользователем, validate_credentials для каждого типа модели.

Реализация поставщика

Узнайте, как реализовать классы поставщика модели для различных поставщиков ИИ-сервисов

Типы моделей

Детали реализации пяти поддерживаемых типов моделей: LLM, Embedding, Rerank, Speech2Text и Text2Speech

Структуры данных

Полный справочник по всем структурам данных, используемым в API модели

Обработка ошибок

Рекомендации по правильному сопоставлению ошибок и обработке исключений

Поставщик модели

Каждый поставщик модели должен наследоваться от базового класса __base.model_provider.ModelProvider и реализовывать интерфейс проверки учётных данных.

Проверка учётных данных поставщика

def validate_provider_credentials(self, credentials: dict) -> None:
    """
    Validate provider credentials by making a test API call
    
    Parameters:
        credentials: Provider credentials as defined in `provider_credential_schema`
        
    Raises:
        CredentialsValidateFailedError: If validation fails
    """
    try:
        # Example implementation - validate using an LLM model instance
        model_instance = self.get_model_instance(ModelType.LLM)
        model_instance.validate_credentials(
            model="example-model", 
            credentials=credentials
        )
    except Exception as ex:
        logger.exception(f"Credential validation failed")
        raise CredentialsValidateFailedError(f"Invalid credentials: {str(ex)}")

class XinferenceProvider(Provider):
    def validate_provider_credentials(self, credentials: dict) -> None:
        """
        For custom-only model providers, a simple implementation is sufficient
        as validation happens at the model level
        """
        pass

dict

Информация об учётных данных, как определено в YAML-конфигурации поставщика в разделе provider_credential_schema. Обычно включает такие поля, как api_key, organization_id и т. п.

Если проверка не пройдена, ваша реализация должна вызвать исключение CredentialsValidateFailedError. Это обеспечивает корректную обработку ошибок в интерфейсе Интеллос.

Для предопределённых поставщиков моделей следует реализовать тщательный метод проверки, который убеждается, что учётные данные работают с вашим API. Для поставщиков пользовательских моделей (где у каждой модели свои учётные данные) достаточно упрощённой реализации.

Модели

Интеллос поддерживает пять различных типов моделей, каждый из которых требует реализации определённых интерфейсов. При этом все типы моделей разделяют некоторые общие требования.

Общие интерфейсы

Каждая реализация модели, независимо от типа, должна реализовывать эти два основных метода:

1. Проверка учётных данных модели

def validate_credentials(self, model: str, credentials: dict) -> None:
    """
    Validate that the provided credentials work with the specified model
    
    Parameters:
        model: The specific model identifier (e.g., "gpt-4")
        credentials: Authentication details for the model
        
    Raises:
        CredentialsValidateFailedError: If validation fails
    """
    try:
        # Make a lightweight API call to verify credentials
        # Example: List available models or check account status
        response = self._api_client.validate_api_key(credentials["api_key"])
        
        # Verify the specific model is available if applicable
        if model not in response.get("available_models", []):
            raise CredentialsValidateFailedError(f"Model {model} is not available")
            
    except ApiException as e:
        raise CredentialsValidateFailedError(str(e))

string

required

Идентификатор конкретной модели для проверки (например, “gpt-4”, “claude-3-opus”)

dict

required

Информация об учётных данных, как определено в конфигурации поставщика

2. Сопоставление ошибок

@property
def _invoke_error_mapping(self) -> dict[type[InvokeError], list[type[Exception]]]:
    """
    Map provider-specific exceptions to standardized Интеллос error types
    
    Returns:
        Dictionary mapping Интеллос error types to lists of provider exception types
    """
    return {
        InvokeConnectionError: [
            requests.exceptions.ConnectionError,
            requests.exceptions.Timeout,
            ConnectionRefusedError
        ],
        InvokeServerUnavailableError: [
            ServiceUnavailableError,
            HTTPStatusError
        ],
        InvokeRateLimitError: [
            RateLimitExceededError,
            QuotaExceededError
        ],
        InvokeAuthorizationError: [
            AuthenticationError,
            InvalidAPIKeyError,
            PermissionDeniedError
        ],
        InvokeBadRequestError: [
            InvalidRequestError,
            ValidationError
        ]
    }

Доступные типы ошибок

class

Сбои сетевого подключения, тайм-ауты

class

Поставщик сервиса недоступен или не работает

class

Достигнуты лимиты частоты запросов или квоты

class

Проблемы аутентификации или прав доступа

class

Недопустимые параметры или запросы

В качестве альтернативы вы можете вызывать эти стандартизированные типы ошибок напрямую в своём коде вместо того, чтобы полагаться на сопоставление ошибок. Такой подход даёт больше контроля над сообщениями об ошибках.

Реализация LLM

Чтобы реализовать поставщика большой языковой модели, наследуйтесь от базового класса __base.large_language_model.LargeLanguageModel и реализуйте эти методы:

1. Вызов модели

Этот основной метод обрабатывает как потоковые, так и непотоковые вызовы API языковых моделей.

def _invoke(
    self, 
    model: str, 
    credentials: dict,
    prompt_messages: list[PromptMessage], 
    model_parameters: dict,
    tools: Optional[list[PromptMessageTool]] = None, 
    stop: Optional[list[str]] = None,
    stream: bool = True, 
    user: Optional[str] = None
) -> Union[LLMResult, Generator[LLMResultChunk, None, None]]:
    """
    Invoke the language model
    """
    # Prepare API parameters
    api_params = self._prepare_api_parameters(
        model, 
        credentials, 
        prompt_messages, 
        model_parameters,
        tools, 
        stop
    )
    
    try:
        # Choose between streaming and non-streaming implementation
        if stream:
            return self._invoke_stream(model, api_params, user)
        else:
            return self._invoke_sync(model, api_params, user)
            
    except Exception as e:
        # Map errors using the error mapping property
        self._handle_api_error(e)

# Helper methods for streaming and non-streaming calls
def _invoke_stream(self, model, api_params, user):
    # Implement streaming call and yield chunks
    pass
    
def _invoke_sync(self, model, api_params, user):
    # Implement synchronous call and return complete result
    pass

Параметры

string

required

Идентификатор модели (например, “gpt-4”, “claude-3”)

dict

required

Учётные данные для аутентификации в API

list[PromptMessage]

required

Список сообщений в стандартизированном формате Интеллос:

Для моделей completion: включите единственное сообщение UserPromptMessage
Для моделей chat: включите SystemPromptMessage, UserPromptMessage, AssistantPromptMessage, ToolPromptMessage по необходимости

dict

required

Параметры, специфичные для модели (temperature, top_p и т. п.), как определено в YAML-конфигурации модели

list[PromptMessageTool]

Определения инструментов для возможностей вызова функций

list[string]

Последовательности остановки, при обнаружении которых генерация модели прекращается

boolean

default:true

Возвращать ли потоковый ответ

string

Идентификатор пользователя для мониторинга API

Возвращаемые значения

Generator[LLMResultChunk, None, None]

Генератор, выдающий чанки ответа по мере их поступления

LLMResult

Полный объект ответа с целиком сгенерированным текстом

Рекомендуем реализовать отдельные вспомогательные методы для потоковых и непотоковых вызовов, чтобы код оставался организованным и удобным в сопровождении.

2. Подсчёт токенов

def get_num_tokens(
    self, 
    model: str, 
    credentials: dict, 
    prompt_messages: list[PromptMessage],
    tools: Optional[list[PromptMessageTool]] = None
) -> int:
    """
    Calculate the number of tokens in the prompt
    """
    # Convert prompt_messages to the format expected by the tokenizer
    text = self._convert_messages_to_text(prompt_messages)
    
    try:
        # Use the appropriate tokenizer for this model
        tokenizer = self._get_tokenizer(model)
        return len(tokenizer.encode(text))
    except Exception:
        # Fall back to a generic tokenizer
        return self._get_num_tokens_by_gpt2(text)

Если модель не предоставляет токенизатор, для приемлемой оценки можно использовать метод базового класса _get_num_tokens_by_gpt2(text).

3. Схема пользовательской модели (необязательно)

def get_customizable_model_schema(
    self, 
    model: str, 
    credentials: dict
) -> Optional[AIModelEntity]:
    """
    Get parameter schema for custom models
    """
    # For fine-tuned models, you might return the base model's schema
    if model.startswith("ft:"):
        base_model = self._extract_base_model(model)
        return self._get_predefined_model_schema(base_model)
    
    # For standard models, return None to use the predefined schema
    return None

Этот метод необходим только для поставщиков, которые поддерживают пользовательские модели. Он позволяет пользовательским моделям наследовать правила параметров от базовых моделей.

Реализация TextEmbedding

Модели текстовых эмбеддингов преобразуют текст в высокоразмерные векторы, отражающие семантический смысл, что полезно для поиска, поиска по сходству и классификации.

Чтобы реализовать поставщика текстовых эмбеддингов, наследуйтесь от базового класса __base.text_embedding_model.TextEmbeddingModel:

1. Основной метод эмбеддинга

def _invoke(
    self, 
    model: str, 
    credentials: dict,
    texts: list[str], 
    user: Optional[str] = None
) -> TextEmbeddingResult:
    """
    Generate embedding vectors for multiple texts
    """
    # Set up API client with credentials
    client = self._get_client(credentials)
    
    # Handle batching if needed
    batch_size = self._get_batch_size(model)
    all_embeddings = []
    total_tokens = 0
    start_time = time.time()
    
    # Process in batches to avoid API limits
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i+batch_size]
        
        # Make API call to the embeddings endpoint
        response = client.embeddings.create(
            model=model,
            input=batch,
            user=user
        )
        
        # Extract embeddings from response
        batch_embeddings = [item.embedding for item in response.data]
        all_embeddings.extend(batch_embeddings)
        
        # Track token usage
        total_tokens += response.usage.total_tokens
    
    # Calculate usage metrics
    elapsed_time = time.time() - start_time
    usage = self._create_embedding_usage(
        model=model,
        tokens=total_tokens,
        latency=elapsed_time
    )
    
    return TextEmbeddingResult(
        model=model,
        embeddings=all_embeddings,
        usage=usage
    )

Параметры

string

required

Идентификатор эмбеддинг-модели

dict

required

Учётные данные для аутентификации в сервисе эмбеддингов

list[string]

required

Список текстовых входных данных для эмбеддинга

string

Идентификатор пользователя для мониторинга API

Возвращаемое значение

object

required

Структурированный ответ, содержащий:

model: модель, использованная для эмбеддинга
embeddings: список эмбеддинг-векторов, соответствующих входным текстам
usage: метаданные об использовании токенов и стоимости

2. Метод подсчёта токенов

def get_num_tokens(
    self, 
    model: str, 
    credentials: dict, 
    texts: list[str]
) -> int:
    """
    Calculate the number of tokens in the texts to be embedded
    """
    # Join all texts to estimate token count
    combined_text = " ".join(texts)
    
    try:
        # Use the appropriate tokenizer for this model
        tokenizer = self._get_tokenizer(model)
        return len(tokenizer.encode(combined_text))
    except Exception:
        # Fall back to a generic tokenizer
        return self._get_num_tokens_by_gpt2(combined_text)

Для эмбеддинг-моделей точный подсчёт токенов важен для оценки стоимости, но не критичен для работоспособности. Метод _get_num_tokens_by_gpt2 даёт приемлемую оценку для большинства моделей.

Реализация Rerank

Реранкинг-модели помогают улучшить качество поиска, переупорядочивая набор документов-кандидатов на основе их релевантности запросу, как правило, после начального этапа поиска.

Чтобы реализовать поставщика реранкинга, наследуйтесь от базового класса __base.rerank_model.RerankModel:

def _invoke(
    self, 
    model: str, 
    credentials: dict,
    query: str, 
    docs: list[str], 
    score_threshold: Optional[float] = None, 
    top_n: Optional[int] = None,
    user: Optional[str] = None
) -> RerankResult:
    """
    Rerank documents based on relevance to the query
    """
    # Set up API client with credentials
    client = self._get_client(credentials)
    
    # Prepare request data
    request_data = {
        "query": query,
        "documents": docs,
    }
    
    # Call reranking API endpoint
    response = client.rerank(
        model=model,
        **request_data,
        user=user
    )
    
    # Process results
    ranked_results = []
    for i, result in enumerate(response.results):
        # Create RerankDocument for each result
        doc = RerankDocument(
            index=result.document_index,  # Original index in docs list
            text=docs[result.document_index],  # Original text
            score=result.relevance_score  # Relevance score
        )
        ranked_results.append(doc)
    
    # Sort by score in descending order
    ranked_results.sort(key=lambda x: x.score, reverse=True)
    
    # Apply score threshold filtering if specified
    if score_threshold is not None:
        ranked_results = [doc for doc in ranked_results if doc.score >= score_threshold]
    
    # Apply top_n limit if specified
    if top_n is not None and top_n > 0:
        ranked_results = ranked_results[:top_n]
    
    return RerankResult(
        model=model,
        docs=ranked_results
    )

Параметры

string

required

Идентификатор реранкинг-модели

dict

required

Учётные данные для аутентификации в API

string

required

Текст поискового запроса

list[string]

required

Список текстов документов для реранкинга

float

Необязательный минимальный порог оценки для фильтрации результатов

int

Необязательное ограничение на количество возвращаемых результатов

string

Идентификатор пользователя для мониторинга API

Возвращаемое значение

object

required

Структурированный ответ, содержащий:

model: модель, использованная для реранкинга
docs: список объектов RerankDocument с полями index, text и score

Реранкинг может требовать значительных вычислительных ресурсов, особенно при больших наборах документов. Реализуйте пакетную обработку для крупных коллекций документов, чтобы избежать тайм-аутов или чрезмерного потребления ресурсов.

Реализация Speech2Text

Модели распознавания речи преобразуют устную речь из аудиофайлов в письменный текст, делая возможными такие приложения, как сервисы транскрипции, голосовые команды и функции доступности.

Чтобы реализовать поставщика распознавания речи, наследуйтесь от базового класса __base.speech2text_model.Speech2TextModel:

def _invoke(
    self, 
    model: str, 
    credentials: dict,
    file: IO[bytes], 
    user: Optional[str] = None
) -> str:
    """
    Convert speech audio to text
    """
    # Set up API client with credentials
    client = self._get_client(credentials)
    
    try:
        # Determine the file format
        file_format = self._detect_audio_format(file)
        
        # Prepare the file for API submission
        # Most APIs require either a file path or binary data
        audio_data = file.read()
        
        # Call the speech-to-text API
        response = client.audio.transcriptions.create(
            model=model,
            file=("audio.mp3", audio_data),  # Adjust filename based on actual format
            user=user
        )
        
        # Extract and return the transcribed text
        return response.text
        
    except Exception as e:
        # Map to appropriate error type
        self._handle_api_error(e)
        
    finally:
        # Reset file pointer for potential reuse
        file.seek(0)

def _detect_audio_format(self, file: IO[bytes]) -> str:
    """
    Detect the audio format based on file header
    """
    # Read the first few bytes to check the file signature
    header = file.read(12)
    file.seek(0)  # Reset file pointer
    
    # Check for common audio format signatures
    if header.startswith(b'RIFF') and header[8:12] == b'WAVE':
        return 'wav'
    elif header.startswith(b'ID3') or header.startswith(b'\xFF\xFB'):
        return 'mp3'
    elif header.startswith(b'OggS'):
        return 'ogg'
    elif header.startswith(b'fLaC'):
        return 'flac'
    else:
        # Default or additional format checks
        return 'mp3'  # Default assumption

Параметры

string

required

Идентификатор модели распознавания речи

dict

required

Учётные данные для аутентификации в API

IO[bytes]

required

Бинарный файловый объект, содержащий аудио для транскрибирования

string

Идентификатор пользователя для мониторинга API

Возвращаемое значение

string

required

Текст, транскрибированный из аудиофайла

Определение формата аудио важно для корректной обработки разных типов файлов. Рассмотрите возможность реализации вспомогательного метода для определения формата по заголовку файла, как показано в примере.

Некоторые API распознавания речи имеют ограничения на размер файла. При необходимости рассмотрите реализацию чанкинга для больших аудиофайлов.

Реализация Text2Speech

Модели синтеза речи преобразуют письменный текст в естественно звучащую речь, делая возможными такие приложения, как голосовые ассистенты, программы чтения с экрана и генерация аудиоконтента.

Чтобы реализовать поставщика синтеза речи, наследуйтесь от базового класса __base.text2speech_model.Text2SpeechModel:

def _invoke(
    self, 
    model: str, 
    credentials: dict, 
    content_text: str, 
    streaming: bool,
    user: Optional[str] = None
) -> Union[bytes, Generator[bytes, None, None]]:
    """
    Convert text to speech audio
    """
    # Set up API client with credentials
    client = self._get_client(credentials)
    
    # Get voice settings based on model
    voice = self._get_voice_for_model(model)
    
    try:
        # Choose implementation based on streaming preference
        if streaming:
            return self._stream_audio(
                client=client,
                model=model,
                text=content_text,
                voice=voice,
                user=user
            )
        else:
            return self._generate_complete_audio(
                client=client,
                model=model,
                text=content_text,
                voice=voice,
                user=user
            )
    except Exception as e:
        self._handle_api_error(e)

def _stream_audio(self, client, model, text, voice, user=None):
    """
    Implementation for streaming audio output
    """
    # Make API request with stream=True
    response = client.audio.speech.create(
        model=model,
        voice=voice,
        input=text,
        stream=True,
        user=user
    )
    
    # Yield chunks as they arrive
    for chunk in response:
        if chunk:
            yield chunk
            
def _generate_complete_audio(self, client, model, text, voice, user=None):
    """
    Implementation for complete audio file generation
    """
    # Make API request for complete audio
    response = client.audio.speech.create(
        model=model,
        voice=voice,
        input=text,
        user=user
    )
    
    # Get audio data as bytes
    audio_data = response.content
    return audio_data

Параметры

string

required

Идентификатор модели синтеза речи

dict

required

Учётные данные для аутентификации в API

string

required

Текстовое содержимое для преобразования в речь

boolean

required

Возвращать ли потоковое аудио или полный файл

string

Идентификатор пользователя для мониторинга API

Возвращаемое значение

Generator[bytes, None, None]

Генератор, выдающий аудиочанки по мере их поступления

bytes

Полные аудиоданные в виде байтов

Большинство API синтеза речи требуют указывать голос вместе с моделью. Рассмотрите возможность реализации сопоставления между идентификаторами моделей Интеллос и вариантами голоса поставщика.

Длинные текстовые входные данные может потребоваться разбить на чанки для лучшего качества синтеза речи. Рассмотрите реализацию предварительной обработки текста для корректной обработки пунктуации, чисел и специальных символов.

Реализация Moderation

Модели модерации анализируют контент на наличие потенциально вредоносного, неуместного или небезопасного материала, помогая поддерживать безопасность платформы и соблюдение политик в отношении контента.

Чтобы реализовать поставщика модерации, наследуйтесь от базового класса __base.moderation_model.ModerationModel:

def _invoke(
    self, 
    model: str, 
    credentials: dict,
    text: str, 
    user: Optional[str] = None
) -> bool:
    """
    Analyze text for harmful content
    
    Returns:
        bool: False if the text is safe, True if it contains harmful content
    """
    # Set up API client with credentials
    client = self._get_client(credentials)
    
    try:
        # Call moderation API
        response = client.moderations.create(
            model=model,
            input=text,
            user=user
        )
        
        # Check if any categories were flagged
        result = response.results[0]
        
        # Return True if flagged in any category, False if safe
        return result.flagged
        
    except Exception as e:
        # Log the error but default to safe if there's an API issue
        # This is a conservative approach - production systems might want
        # different fallback behavior
        logger.error(f"Moderation API error: {str(e)}")
        return False

def _invoke(
    self, 
    model: str, 
    credentials: dict,
    text: str, 
    user: Optional[str] = None
) -> bool:
    """
    Analyze text for harmful content with detailed category checking
    """
    # Set up API client with credentials
    client = self._get_client(credentials)
    
    try:
        # Call moderation API
        response = client.moderations.create(
            model=model,
            input=text,
            user=user
        )
        
        # Get detailed category results
        result = response.results[0]
        categories = result.categories
        
        # Check specific categories based on your application's needs
        # For example, you might want to flag certain categories but not others
        critical_violations = [
            categories.harassment,
            categories.hate,
            categories.self_harm,
            categories.sexual,
            categories.violence
        ]
        
        # Flag content if any critical category is violated
        return any(critical_violations)
        
    except Exception as e:
        self._handle_api_error(e)
        # Default to safe in case of error
        return False

Параметры

string

required

Идентификатор модели модерации

dict

required

Учётные данные для аутентификации в API

string

required

Текстовое содержимое для анализа

string

Идентификатор пользователя для мониторинга API

Возвращаемое значение

boolean

required

Булево значение, указывающее на безопасность контента:

False: контент безопасен
True: контент содержит вредоносный материал

Модерация часто используется как механизм безопасности. При реализации своего решения учитывайте последствия ложноотрицательных срабатываний (пропуск вредоносного контента) и ложноположительных (блокировка безопасного контента).

Многие API модерации предоставляют детальные оценки по категориям, а не только бинарный результат. Рассмотрите возможность расширения этой реализации, чтобы возвращать более подробную информацию о конкретных категориях вредоносного контента, если этого требует ваше приложение.

Сущности

PromptMessageRole

Роль сообщения

class PromptMessageRole(Enum):
    """
    Enum class for prompt message.
    """
    SYSTEM = "system"
    USER = "user"
    ASSISTANT = "assistant"
    TOOL = "tool"

PromptMessageContentType

Тип содержимого сообщения, разделённый на обычный текст и изображения.

class PromptMessageContentType(Enum):
    """
    Enum class for prompt message content type.
    """
    TEXT = 'text'
    IMAGE = 'image'

PromptMessageContent

Базовый класс содержимого сообщения, используется только для объявления параметров, не может быть инициализирован.

class PromptMessageContent(BaseModel):
    """
    Model class for prompt message content.
    """
    type: PromptMessageContentType
    data: str  # Content data

В настоящее время поддерживаются два типа: текст и изображения; можно одновременно использовать текст и несколько изображений. Необходимо отдельно инициализировать TextPromptMessageContent и ImagePromptMessageContent.

TextPromptMessageContent

class TextPromptMessageContent(PromptMessageContent):
    """
    Model class for text prompt message content.
    """
    type: PromptMessageContentType = PromptMessageContentType.TEXT

При передаче текста и изображений текст нужно сконструировать как эту сущность в составе списка content.

ImagePromptMessageContent

class ImagePromptMessageContent(PromptMessageContent):
    """
    Model class for image prompt message content.
    """
    class DETAIL(Enum):
        LOW = 'low'
        HIGH = 'high'

    type: PromptMessageContentType = PromptMessageContentType.IMAGE
    detail: DETAIL = DETAIL.LOW  # Resolution

При передаче текста и изображений изображения нужно сконструировать как эту сущность в составе списка content. data может быть url или строкой изображения в кодировке base64.

PromptMessage

Базовый класс для всех тел сообщений Role, используется только для объявления параметров, не может быть инициализирован.

class PromptMessage(ABC, BaseModel):
    """
    Model class for prompt message.
    """
    role: PromptMessageRole  # Message role
    content: Optional[str | list[PromptMessageContent]] = None  # Supports two types: string and content list. The content list is for multimodal needs, see PromptMessageContent for details.
    name: Optional[str] = None  # Name, optional.

UserPromptMessage

Тело сообщения UserMessage, представляет сообщения пользователя.

class UserPromptMessage(PromptMessage):
    """
    Model class for user prompt message.
    """
    role: PromptMessageRole = PromptMessageRole.USER

AssistantPromptMessage

Представляет сообщения-ответы модели, обычно используется для few-shots или ввода истории чата.

class AssistantPromptMessage(PromptMessage):
    """
    Model class for assistant prompt message.
    """
    class ToolCall(BaseModel):
        """
        Model class for assistant prompt message tool call.
        """
        class ToolCallFunction(BaseModel):
            """
            Model class for assistant prompt message tool call function.
            """
            name: str  # Tool name
            arguments: str  # Tool parameters

        id: str  # Tool ID, only effective for OpenAI tool call, a unique ID for tool invocation, the same tool can be called multiple times
        type: str  # Default is function
        function: ToolCallFunction  # Tool call information

    role: PromptMessageRole = PromptMessageRole.ASSISTANT
    tool_calls: list[ToolCall] = []  # Model's tool call results (only returned when tools are passed in and the model decides to call them)

Здесь tool_calls — это список tool call, возвращаемый моделью после передачи ей tools.

SystemPromptMessage

Представляет системные сообщения, обычно используется для задания системных инструкций модели.

class SystemPromptMessage(PromptMessage):
    """
    Model class for system prompt message.
    """
    role: PromptMessageRole = PromptMessageRole.SYSTEM

ToolPromptMessage

Представляет сообщения инструментов, используется для передачи результатов модели для планирования следующего шага после того, как инструмент был выполнен.

class ToolPromptMessage(PromptMessage):
    """
    Model class for tool prompt message.
    """
    role: PromptMessageRole = PromptMessageRole.TOOL
    tool_call_id: str  # Tool call ID, if OpenAI tool call is not supported, you can also pass in the tool name

Поле content базового класса передаёт результат выполнения инструмента.

PromptMessageTool

class PromptMessageTool(BaseModel):
    """
    Model class for prompt message tool.
    """
    name: str  # Tool name
    description: str  # Tool description
    parameters: dict  # Tool parameters dict

LLMResult

class LLMResult(BaseModel):
    """
    Model class for llm result.
    """
    model: str  # Actually used model
    prompt_messages: list[PromptMessage]  # Prompt message list
    message: AssistantPromptMessage  # Reply message
    usage: LLMUsage  # Tokens used and cost information
    system_fingerprint: Optional[str] = None  # Request fingerprint, refer to OpenAI parameter definition

LLMResultChunkDelta

Сущность delta для каждой итерации в потоковом ответе

class LLMResultChunkDelta(BaseModel):
    """
    Model class for llm result chunk delta.
    """
    index: int  # Sequence number
    message: AssistantPromptMessage  # Reply message
    usage: Optional[LLMUsage] = None  # Tokens used and cost information, only returned in the last message
    finish_reason: Optional[str] = None  # Completion reason, only returned in the last message

LLMResultChunk

Сущность итерации в потоковом ответе

class LLMResultChunk(BaseModel):
    """
    Model class for llm result chunk.
    """
    model: str  # Actually used model
    prompt_messages: list[PromptMessage]  # Prompt message list
    system_fingerprint: Optional[str] = None  # Request fingerprint, refer to OpenAI parameter definition
    delta: LLMResultChunkDelta  # Changes in content for each iteration

LLMUsage

class LLMUsage(ModelUsage):
    """
    Model class for llm usage.
    """
    prompt_tokens: int  # Tokens used by prompt
    prompt_unit_price: Decimal  # Prompt unit price
    prompt_price_unit: Decimal  # Prompt price unit, i.e., unit price based on how many tokens
    prompt_price: Decimal  # Prompt cost
    completion_tokens: int  # Tokens used by completion
    completion_unit_price: Decimal  # Completion unit price
    completion_price_unit: Decimal  # Completion price unit, i.e., unit price based on how many tokens
    completion_price: Decimal  # Completion cost
    total_tokens: int  # Total tokens used
    total_price: Decimal  # Total cost
    currency: str  # Currency unit
    latency: float  # Request time (s)

TextEmbeddingResult

class TextEmbeddingResult(BaseModel):
    """
    Model class for text embedding result.
    """
    model: str  # Actually used model
    embeddings: list[list[float]]  # Embedding vector list, corresponding to the input texts list
    usage: EmbeddingUsage  # Usage information

EmbeddingUsage

class EmbeddingUsage(ModelUsage):
    """
    Model class for embedding usage.
    """
    tokens: int  # Tokens used
    total_tokens: int  # Total tokens used
    unit_price: Decimal  # Unit price
    price_unit: Decimal  # Price unit, i.e., unit price based on how many tokens
    total_price: Decimal  # Total cost
    currency: str  # Currency unit
    latency: float  # Request time (s)

RerankResult

class RerankResult(BaseModel):
    """
    Model class for rerank result.
    """
    model: str  # Actually used model
    docs: list[RerankDocument]  # List of reranked segments        

RerankDocument

class RerankDocument(BaseModel):
    """
    Model class for rerank document.
    """
    index: int  # Original sequence number
    text: str  # Segment text content
    score: float  # Score

Связанные ресурсы

Правила проектирования моделей — изучите стандарты конфигурации моделей
Введение в плагины моделей — быстро ознакомьтесь с базовыми концепциями плагинов моделей
Быстрая интеграция новой модели — узнайте, как добавить новые модели к существующим поставщикам
Создание нового поставщика модели — узнайте, как разрабатывать совершенно новых поставщиков моделей

Edit this page | Report an issue

​Введение

​Быстрое решение: какой метод реализовывать?

Реализация поставщика

Типы моделей

Структуры данных

Обработка ошибок

​Поставщик модели

​Проверка учётных данных поставщика

​Модели

​Общие интерфейсы

​1. Проверка учётных данных модели

​2. Сопоставление ошибок

​Реализация LLM

​1. Вызов модели

​2. Подсчёт токенов

​3. Схема пользовательской модели (необязательно)

​Реализация TextEmbedding

​1. Основной метод эмбеддинга

​2. Метод подсчёта токенов

​Реализация Rerank

​Реализация Speech2Text

​Реализация Text2Speech

​Реализация Moderation

​Сущности

​PromptMessageRole

​PromptMessageContentType

​PromptMessageContent

​TextPromptMessageContent

​ImagePromptMessageContent

​PromptMessage

​UserPromptMessage

​AssistantPromptMessage

​SystemPromptMessage

​ToolPromptMessage

​PromptMessageTool

​LLMResult

​LLMResultChunkDelta

​LLMResultChunk

​LLMUsage

​TextEmbeddingResult

​EmbeddingUsage

​RerankResult

​RerankDocument

​Связанные ресурсы

Введение

Быстрое решение: какой метод реализовывать?

Поставщик модели

Проверка учётных данных поставщика

Модели

Общие интерфейсы

1. Проверка учётных данных модели

2. Сопоставление ошибок

Реализация LLM

1. Вызов модели

2. Подсчёт токенов

3. Схема пользовательской модели (необязательно)

Реализация TextEmbedding

1. Основной метод эмбеддинга

2. Метод подсчёта токенов

Реализация Rerank

Реализация Speech2Text

Реализация Text2Speech

Реализация Moderation

Сущности

PromptMessageRole

PromptMessageContentType

PromptMessageContent

TextPromptMessageContent

ImagePromptMessageContent

PromptMessage

UserPromptMessage

AssistantPromptMessage

SystemPromptMessage

ToolPromptMessage

PromptMessageTool

LLMResult

LLMResultChunkDelta

LLMResultChunk

LLMUsage

TextEmbeddingResult

EmbeddingUsage

RerankResult

RerankDocument

Связанные ресурсы