html 🚰 Função do tubo | Nullcore
Pule para o conteúdo principal

🚰 Função do tubo: Crie "agentes/modelos" personalizados

Bem -vindo a este guia sobre a criaçãoTubosem webui aberto! Pense nos tubos como uma maneira deadicionandoUm novo modelo para abrir Webui. Neste documento, quebraremos o que é um tubo, como ele funciona e como você pode criar o seu para adicionar lógica e processamento personalizados aos seus modelos abertos do WebUI. Usaremos metáforas claras e passaremos por todos os detalhes para garantir que você tenha um entendimento abrangente.

Introdução aos tubos

Imagine o Nullcore como umsistema de encanamentoonde os dados fluem através de tubos e válvulas. Nesta analogia:

  • Tubossão comopluginsIsso permite introduzir novos caminhos para o fluxo de dados, permitindo injetar lógica e processamento personalizados.
  • Válvulassão ospartes configuráveisdo seu tubo que controlam como os dados fluem através dele.

Ao criar um tubo, você está criando essencialmente um modelo personalizado com o comportamento específico desejado, tudo dentro da estrutura aberta do WebUi.

Compreendendo a estrutura do tubo

Vamos começar com uma versão básica e barebones de um tubo para entender sua estrutura:

dePydanticimportarBasemodel, Assim,Campo

aula Cano
    aula VálvulasBasemodel
Model_id str Campopadrão

    def __init__auto
autoválvulasautoVálvulas

    def canoauto, Assim,corpo dito
        # Lógica vai aqui
        imprimirautoválvulas, Assim,corpo  # Isso imprimirá as opções de configuração e o corpo de entrada
        retornar "Olá, mundo!"

A classe de tubo

  • Definição: OPipeA classe é onde você define sua lógica personalizada.
  • Propósito: Atua como o plano para o seu plug -in, determinando como ele se comporta no Webui aberto.

Válvulas: configurando seu cachimbo

  • DefiniçãoValvesé uma classe aninhada dentroPipe, herdando deBaseModel
  • Propósito: Ele contém as opções de configuração (parâmetros) que persistem no uso do seu tubo.
  • Exemplo: No código acima,MODEL_IDé uma opção de configuração com uma sequência vazia padrão.

Metáfora: Pense nas válvulas como os botões em um sistema de tubos do mundo real que controlam o fluxo de água. No seu tubo, as válvulas permitem que os usuários ajustem as configurações que influenciam como os dados fluem e são processados.

O__init__Método

  • Definição: O método construtor para oPipeaula.
  • Propósito: Inicializa o estado do tubo e configura os componentes necessários.
  • Prática recomendada: Mantenha -o simples; inicialize principalmenteself.valvesaqui.
def __init__auto
autoválvulasautoVálvulas

OpipeFunção

  • Definição: A função principal em que sua lógica personalizada reside.
  • Parâmetros
    • body: Um dicionário que contém os dados de entrada.
  • Propósito: Processa os dados de entrada usando sua lógica personalizada e retorna o resultado.
def canoauto, Assim,corpo dito
    # Lógica vai aqui
    imprimirautoválvulas, Assim,corpo  # Isso imprimirá as opções de configuração e o corpo de entrada
    retornar "Olá, mundo!"

Observação: Sempre coloqueValvesno topo do seuPipeclasse, seguida de__init__, e então opipefunção. Essa estrutura garante clareza e consistência.

Criando vários modelos com tubos

E se você quiser que seu tubo crieVários modelosdentro de webui aberto? Você pode conseguir isso definindo umpipesfunção ou variável dentro do seuPipeaula. Esta configuração, informalmente chamada de umcoletor, permite que seu tubo represente vários modelos.

Veja como você pode fazer isso:

dePydanticimportarBasemodel, Assim,Campo

aula Cano
    aula VálvulasBasemodel
Model_id str Campopadrão

    def __init__auto
autoválvulasautoVálvulas

    def tubosauto
        retornar [[
            {"eu ia" "Model_id_1", Assim, "nome" "Model_1", Assim,
            {"eu ia" "Model_id_2", Assim, "nome" "Model_2", Assim,
            {"eu ia" "Model_id_3", Assim, "nome" "Model_3", Assim,
        

    def canoauto, Assim,corpo dito
        # Lógica vai aqui
        imprimirautoválvulas, Assim,corpo  # Imprime as opções de configuração e o corpo de entrada
modelocorpopegar"modelo", Assim, 
        retornar f "{modelo: Olá, mundo! "

Explicação

  • pipesFunção

    • Retorna uma lista de dicionários.
    • Cada dicionário representa um modelo com exclusivoidenamechaves.
    • Esses modelos aparecerão individualmente no seletor de modelo Nullcore.

  • AtualizadopipeFunção

    • Processa a entrada com base no modelo selecionado.
    • Neste exemplo, inclui o nome do modelo na sequência retornada.

Exemplo: OpenAI Proxy Pipe

Vamos mergulhar em um exemplo prático em que criaremos um tubo que proxies solicitações para a API OpenAI. Este tubo buscará modelos disponíveis do OpenAI e permitirá que os usuários interajam com eles através do Nullcore.

dePydanticimportarBasemodel, Assim,Campo
importarsolicitações

aula Cano
    aula VálvulasBasemodel
Name_prefix str Campo
padrão"Openai/", Assim,
descrição"Prefixo a ser adicionado antes dos nomes dos modelos.", Assim,
        
Openai_API_Base_URL str Campo
padrão"https://api.openai.com/v1", Assim,
descrição"URL base para acessar os terminais da API OpenAI.", Assim,
        
OpenAi_API_KEY str Campo
padrão, Assim,
descrição"Chave da API para autenticar solicitações à API OpenAI"., Assim,
        

    def __init__auto
autoválvulasautoVálvulas

    def tubosauto
        seautoválvulasOpenAi_API_KEY
            tentar
cabeçalhos {
                    "Autorização" f "Portador{autoválvulasOpenAi_API_KEY, Assim,
                    "Tipo de conteúdo" "Aplicativo/JSON", Assim,
                

rsolicitaçõespegar
                    f "{autoválvulasOpenai_API_Base_URL/modelos ", Assim,cabeçalhoscabeçalhos
                
modelosrJSON
                retornar [[
                    {
                        "eu ia"modelo[["eu ia", Assim,
                        "nome" f '{autoválvulasName_prefix{modelopegar"nome", Assim,modelo[["eu ia", Assim,
                    
                    paramodeloemmodelos[["dados"
                    se "GPT" emmodelo[["eu ia"
                

            excetoExceçãocomoe
                retornar [[
                    {
                        "eu ia" "erro", Assim,
                        "nome" "Erro a buscar modelos. Por favor, verifique sua chave da API.", Assim,
                    , Assim,
                
        outro
            retornar [[
                {
                    "eu ia" "erro", Assim,
                    "nome" "Chave da API não fornecida.", Assim,
                , Assim,
            

    def canoauto, Assim,corpo dito, Assim,__usuário__ dito
        imprimirf "tubo:{__nome__
cabeçalhos {
            "Autorização" f "Portador{autoválvulasOpenAi_API_KEY, Assim,
            "Tipo de conteúdo" "Aplicativo/JSON", Assim,
        

        # Extrair ID do modelo do nome do modelo
model_idcorpo[["modelo"[[corpo[["modelo"encontrar  1 

        # Atualize o ID do modelo no corpo
carga útil {corpo, Assim, "modelo"model_id
        tentar
rsolicitaçõespublicar
urlf "{autoválvulasOpenai_API_Base_URL/Chat/Concluir ", Assim,
JSONcarga útil, Assim,
cabeçalhoscabeçalhos, Assim,
fluxoVerdadeiro, Assim,
            

rRaise_for_status

            secorpopegar"fluxo", Assim, Falso
                retornarriter_lines
            outro
                retornarrJSON
        excetoExceçãocomoe
            retornar f "Erro:{e

Quebra detalhada

Configuração das válvulas

  • NAME_PREFIX
    • Adiciona um prefixo aos nomes de modelos exibidos no webui aberto.
    • Padrão:"OPENAI/"
  • OPENAI_API_BASE_URL
    • Especifica o URL base da API OpenAI.
    • Padrão:"https://api.openai.com/v1"
  • OPENAI_API_KEY
    • Sua chave de API do OpenAI para autenticação.
    • Padrão:""(string vazia; deve ser fornecido).

OpipesFunção

  • Propósito: Busca modelos OpenAI disponíveis e os torna acessíveis em webui aberto.

  • Processo

    1. Verifique a chave da API: Garante que uma chave da API seja fornecida.
    2. Fetch Models: Faça uma solicitação de obter à API OpenAI para recuperar os modelos disponíveis.
    3. Modelos de filtro: Retorna modelos que têm"gpt"em seusid
    4. Manuseio de erros: Se houver um problema, retorne uma mensagem de erro.

  • Formato de retorno: Uma lista de dicionários comidenamepara cada modelo.

OpipeFunção

  • Propósito: Lida com a solicitação ao modelo OpenAI selecionado e retorna a resposta.

  • Parâmetros

    • body: Contém os dados da solicitação.
    • __user__: Contém informações do usuário (não usado neste exemplo, mas pode ser útil para autenticação ou log).

  • Processo

    1. Prepare cabeçalhos: Configura os cabeçalhos com a chave da API e o tipo de conteúdo.
    2. Extrair ID do modelo: Extrai o ID do modelo real do nome do modelo selecionado.
    3. Prepare a carga útil: Atualiza o corpo com o ID do modelo correto.
    4. Faça solicitação da API: Envia uma solicitação de postagem para o endpoint de conclusão de bate -papo da API do OpenAI.
    5. Manuseie o streaming: SestreaméTrue, retorna um iterável das linhas.
    6. Manuseio de erros: Captura exceções e retorna uma mensagem de erro.

Estendendo o tubo de proxy

Você pode modificar este tubo de proxy para suportar provedores de serviços adicionais, como antropia, perplexidade e mais, ajustando os terminais da API, cabeçalhos e lógica dentro dopipesepipefunções.

Usando funções internas de webui aberto

Às vezes, você pode querer aproveitar as funções internas do webui aberto dentro do seu tubo. Você pode importar essas funções diretamente doopen_webuipacote. Lembre -se de que, embora improvável, as funções internas podem mudar para fins de otimização; portanto, sempre consulte a documentação mais recente.

Veja como você pode usar as funções internas de webui aberto:

dePydanticimportarBasemodel, Assim,Campo
deFASTAPIimportarSolicitar

deopen_webuimodelosUsuáriosimportarUsuários
deopen_webuiUTILSbater papoimportargenerate_chat_completion

aula Cano
    def __init__auto
        passar

    assíncrono def cano
auto, Assim,
corpo dito, Assim,
__usuário__ dito, Assim,
__solicitar__Solicitar, Assim,
      str
        # Use o endpoint unificado com a assinatura atualizada
usuárioUsuáriosget_user_by_id__usuário__[["eu ia"
corpo[["modelo"  "LLAMA3.2: mais recente"
        retornar aguardegenerate_chat_completion__solicitar__, Assim,corpo, Assim,usuário

Explicação

  • Importações

    • Usersdeopen_webui.models.users: Para buscar informações do usuário.
    • generate_chat_completiondeopen_webui.utils.chat: Para gerar conclusões de bate -papo usando a lógica interna.

  • AssíncronopipeFunção

    • Parâmetros
      • body: Dados de entrada para o modelo.
      • __user__: Dicionário contendo informações do usuário.
      • __request__: O objeto de solicitação do FASTAPI (exigido porgenerate_chat_completion
    • Processo
      1. Buscar objeto de usuário: Recupera o objeto do usuário usando seu ID.
      2. Set Model: Especifica o modelo a ser usado.
      3. Gerar conclusão: Chamadasgenerate_chat_completionPara processar a entrada e produzir uma saída.

Notas importantes

  • Assinaturas de função: Consulte a base de código ou documentação ou documentação aberta do Web Open para obter as assinaturas e parâmetros de função mais precisos.
  • Práticas recomendadas: Sempre lide com exceções e erros graciosamente para garantir uma experiência suave do usuário.

Perguntas frequentes

Q1: Por que devo usar tubos em webui aberto?

UM: Os tubos permitem que você adicione um novo "modelo" com lógica e processamento personalizados para abrir o WebUI. É um sistema de plug -in flexível que permite integrar APIs externas, personalizar comportamentos de modelo e criar recursos inovadores sem alterar a base de código principal.

P2: O que são válvulas e por que elas são importantes?

UM: As válvulas são os parâmetros configuráveis ​​do seu tubo. Eles funcionam como configurações ou controles que determinam como seu tubo opera. Ao ajustar as válvulas, você pode alterar o comportamento do seu tubo sem modificar o código subjacente.

Q3: Posso criar um tubo sem válvulas?

UM: Sim, você pode criar um tubo simples sem definir uma classe de válvulas se o seu tubo não exigir nenhuma opção de configuração persistente. No entanto, incluir válvulas é uma boa prática para flexibilidade e escalabilidade futura.

Q4: Como faço para garantir que meu tubo esteja seguro ao usar as teclas da API?

UM: Nunca informações confidenciais de código rígido, como as teclas da API no seu tubo. Em vez disso, use válvulas para inserir e armazenar as teclas da API com segurança. Certifique -se de que seu código lida com essas chaves adequadamente e evite o registro ou exponha -as.

Q5: Qual é a diferença entre opipeepipesfunções?

UM

  • pipeFunção: A função principal em que você processa os dados de entrada e gera uma saída. Ele lida com a lógica para um único modelo.

  • pipesFunção: Permite que seu tubo represente vários modelos retornando uma lista de definições de modelo. Cada modelo aparecerá individualmente em Webui aberto.

Q6: Como posso lidar com erros no meu cachimbo?

UM: Use blocos de tentativa de exceção em seupipeepipesfunções para capturar exceções. Retorne mensagens de erro significativas ou lide com os erros graciosamente para garantir que o usuário seja informado sobre o que deu errado.

Q7: Posso usar bibliotecas externas no meu tubo?

UM: Sim, você pode importar e usar bibliotecas externas, conforme necessário. Certifique -se de que quaisquer dependências sejam instaladas e gerenciadas adequadamente em seu ambiente.

Q8: Como faço para testar meu tubo?

UM: Teste seu tubo executando o Nullcore em um ambiente de desenvolvimento e selecionando seu modelo personalizado na interface. Valide que seu tubo se comporta conforme o esperado com várias entradas e configurações.

Q9: Existem práticas recomendadas para organizar o código do meu tubo?

UM: Sim, siga estas diretrizes:

  • ManterValvesno topo do seuPipeaula.
  • Inicializar variáveis ​​no__init__método, principalmenteself.valves
  • Coloque opipefunção após o__init__método.
  • Use nomes de variáveis ​​claros e descritivos.
  • Comente seu código para clareza.

Q10: Onde posso encontrar a mais recente documentação aberta da Webui?

UM: Visite o repositório ou site oficial do Nullcore para obter as informações mais atualizadas, incluindo assinaturas de funções, exemplos e guias de migração, se ocorrerem alterações.

Conclusão

Até agora, você deve ter um entendimento completo de como criar e usar tubos no Webui aberto. Os tubos oferecem uma maneira poderosa de estender e personalizar os recursos do Nullcore para atender às suas necessidades específicas. Esteja você integrando APIs externas, adicionando novos modelos ou injetando lógica complexa, os tubos fornecem a flexibilidade para que isso aconteça.

Lembre -se de:

  • Use estrutura clara e consistentenas suas aulas de tubulação.
  • Válvulas de alavancagemPara opções configuráveis.
  • Lidar com erros graciosamentepara melhorar a experiência do usuário.
  • Consulte a última documentaçãoPara quaisquer atualizações ou alterações.

Codificação feliz e aproveite estendendo seu webui aberto com tubos!