Integração de Modelos Predefinidos

8 min

Após concluir a integração do fornecedor, o próximo passo é integrar os modelos sob o fornecedor.

Primeiro, precisamos determinar o tipo de modelo a ser integrado e criar o módulo de tipo de modelo correspondente no diretório do respectivo fornecedor.

Os tipos de modelo atualmente suportados são os seguintes:

llm: Modelo de Geração de Texto
text_embedding: Modelo de Embedding de Texto
rerank: Modelo de Reordenação
speech2text: Conversão de Fala para Texto
tts: Conversão de Texto para Fala
moderation: Moderação

Tomando o Anthropic como exemplo, o Anthropic só suporta LLM, então criamos um módulo chamado llm em model_providers.anthropic.

Para modelos predefinidos, precisamos primeiro criar um arquivo YAML nomeado de acordo com o modelo no módulo llm, como: claude-2.1.yaml.

Preparando o YAML do Modelo

provider: anthropic  # Identificador do provedor
label:  # Nome de exibição do provedor, pode ser definido em inglês en_US.
  en_US: Anthropic
icon_small:  # Ícone pequeno do provedor, armazenado no diretório _assets sob o diretório de implementação do provedor correspondente, mesma estratégia de linguagem que label
  en_US: icon_s_en.png
icon_large:  # Ícone grande do provedor, armazenado no diretório _assets sob o diretório de implementação do provedor correspondente, mesma estratégia de linguagem que label
  en_US: icon_l_en.png
supported_model_types:  # Tipos de modelo suportados, Anthropic suporta apenas LLM
- llm
configurate_methods:  # Métodos de configuração suportados, Anthropic suporta apenas modelos predefinidos
- predefined-model
provider_credential_schema:  # Regras de credenciais do provedor, como a Anthropic suporta apenas modelos predefinidos, é necessário definir regras de credenciais unificadas do provedor
  credential_form_schemas:  # Lista de itens do formulário de credenciais
  - variable: anthropic_api_key  # Nome da variável de parâmetro de credencial
    label:  # Nome de exibição
      en_US: API Key
    type: secret-input  # Tipo de formulário, secret-input aqui representa uma caixa de entrada de informações criptografadas, exibindo apenas informações mascaradas ao editar.
    required: true  # Se é obrigatório
    placeholder:  # Informações de PlaceHolder
      en_US: Enter your API Key
  - variable: anthropic_api_url
    label:
      en_US: API URL
    type: text-input  # Tipo de formulário, text-input aqui representa uma caixa de entrada de texto
    required: false
    placeholder:
      en_US: Enter your API URL

Recomenda-se preparar todas as configurações do modelo antes de iniciar a implementação do código do modelo.

Da mesma forma, você pode consultar as informações de configuração YAML nos diretórios de outros fornecedores em model_providers. As regras completas de YAML podem ser encontradas em: Schema.

Implementando o Código de Invocação do Modelo Em seguida, crie um arquivo Python com o mesmo nome llm.py no módulo llm para escrever o código de implementação.

Crie uma classe LLM Anthropic em llm.py, que nomearemos como AnthropicLargeLanguageModel (o nome pode ser arbitrário), herdando da classe base __base.large_language_model.LargeLanguageModel, e implemente os seguintes métodos:

Invocação de LLM

Implemente o método principal para invocação de LLM, suportando respostas tanto em streaming quanto síncronas.

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]:
    """
    Invocar modelo de grande linguagem

    :param model: nome do modelo
    :param credentials: credenciais do modelo
    :param prompt_messages: mensagens de prompt
    :param model_parameters: parâmetros do modelo
    :param tools: ferramentas para chamadas de ferramentas
    :param stop: palavras de parada
    :param stream: resposta em streaming
    :param user: ID único do usuário
    :return: resposta completa ou resultado gerador de fragmentos de resposta em streaming
    """

Ao implementar, observe que você deve usar duas funções para retornar os dados, uma para lidar com respostas síncronas e outra para respostas em streaming. Como o Python reconhece funções que contêm a palavra-chave yield como funções geradoras, retornando um tipo de dado fixo Generator, respostas síncronas e em streaming precisam ser implementadas separadamente, como mostrado abaixo (note que o exemplo abaixo usa parâmetros simplificados, a implementação real deve seguir a lista de parâmetros acima):

def _invoke(self, stream: bool, **kwargs) \
        -> Union[LLMResult, Generator]:
    if stream:
          return self._handle_stream_response(**kwargs)
    return self._handle_sync_response(**kwargs)

def _handle_stream_response(self, **kwargs) -> Generator:
    for chunk in response:
          yield chunk

def _handle_sync_response(self, **kwargs) -> LLMResult:
    return LLMResult(**response)

Pré-cálculo de Tokens de Entrada

Se o modelo não fornecer uma interface de pré-cálculo de tokens, retorne 0 diretamente.

def get_num_tokens(self, model: str, credentials: dict, prompt_messages: list[PromptMessage],
                   tools: Optional[list[PromptMessageTool]] = None) -> int:
    """
    Obter o número de tokens para as mensagens de prompt fornecidas

    :param model: nome do modelo
    :param credentials: credenciais do modelo
    :param prompt_messages: mensagens de prompt
    :param tools: ferramentas para chamadas de ferramentas
    :return:
    """

Validação de Credenciais do Modelo

Semelhante à validação de credenciais do fornecedor, isso valida as credenciais para um único modelo.

def validate_credentials(self, model: str, credentials: dict) -> None:
    """
    Validar credenciais do modelo

    :param model: nome do modelo
    :param credentials: credenciais do modelo
    :return:
    """

Tabela de Mapeamento de Erros de Invocação

Quando ocorre um erro de invocação de modelo, ele precisa ser mapeado para o tipo InvokeError especificado pelo Runtime, facilitando o Paragraph a lidar com diferentes erros de forma distinta.

Erros de Runtime:

InvokeConnectionError: Erro de conexão de invocação
InvokeServerUnavailableError: Serviço de invocação indisponível
InvokeRateLimitError: Limite de taxa de invocação atingido
InvokeAuthorizationError: Falha na autorização de invocação
InvokeBadRequestError: Erro de parâmetro de invocação

@property
def _invoke_error_mapping(self) -> dict[type[InvokeError], list[type[Exception]]]:
    """
    Mapear erro de invocação de modelo para erro unificado
    A chave é o tipo de erro lançado para o chamador
    O valor é o tipo de erro lançado pelo modelo,
    que precisa ser convertido em um tipo de erro unificado para o chamador.

    :return: Mapeamento de erro de invocação
    """

Para descrições de métodos de interface, consulte: Interfaces, e para implementação específica, consulte: llm.py.