Inicie APIs LangChain sem esforço com integração LangServe e MinIO

Nossa jornada pelo mundo inovador do revelou suas capacidades substanciais na transformação do gerenciamento de dados e da funcionalidade de aplicativos. LangChain Por meio de discussões anteriores, nos aprofundamos em vários tópicos enquanto exploramos os intrincados recursos do LangChain. Neste artigo, desenvolveremos os conceitos abordados em "Capacitando Agentes Langchain com MinIO" à medida que expandimos a funcionalidade de um agente MinIO para encapsular habilidades adicionais e implantar o agente personalizado via LangServe. Um passo a passo sobre como aproveitar os carregadores S3 da LangChain e a API OpenAI para criar agentes de IA conversacionais personalizados, estabelecendo uma abordagem simplificada para gerenciamento de dados. Inovando recuperação de bucket S3 com LangChain : Um mergulho profundo no aproveitamento do MinIO, mostrando como o LangChain, juntamente com o GPT da OpenAI, abre novas fronteiras no processamento de dados de IA e ML. Capacitando Agentes LangChain com MinIO : Com base nesses insights, agora voltamos nosso foco para , uma ferramenta essencial na transição de aplicativos LangChain do desenvolvimento para a implantação, simplificando o processo de lançamento de APIs prontas para produção. LangServe LangServe: simplificando a implantação de aplicativos LangChain permanece como a base para os desenvolvedores, eliminando as complexidades tradicionalmente associadas à implantação de API. Ele permite uma transição suave de aplicativos LangChain integrados ao MinIO para APIs acessíveis e fáceis de usar. Veja como LangServe redefine o cenário de implantação: LangServe os recursos de automação do LangServe geram facilmente os endpoints de API necessários, simplificando os esforços de desenvolvimento e reduzindo significativamente o tempo de implantação. Criação automática de endpoints de API: Com sua inferência de esquema inteligente, LangServe garante que as APIs ofereçam interfaces bem definidas, facilitando a integração e uma experiência de usuário perfeita. Geração e validação de esquema: LangServe oferece uma variedade de endpoints para atender às diversas necessidades de aplicativos, desde operações síncronas até atualizações em tempo real, proporcionando aos desenvolvedores uma flexibilidade incomparável. Configuração personalizável de endpoints: Talvez seu recurso mais atraente, a capacidade do LangServe de se integrar perfeitamente ao código LangChain existente, significa que os desenvolvedores podem aproveitar sua base de código e experiência atuais sem alterações significativas. Integração sem esforço: Mergulhando profundamente em LangChain e Langserve Iremos nos aprofundar no processo de integração do MinIO com LangChain nas etapas a seguir. Crie um aplicativo LangChain com . langchain-cli Desenvolva um agente LangChain personalizado em um arquivo . agent.py Implemente nosso agente em para rodar como uma API LangServe. server.py Usando a interface de linha de comando do LangChain para criar aplicativos A implantação de aplicativos LangChain com LangServe traz uma jornada de integração perfeita, preenchendo a lacuna entre funcionalidades complexas de IA e a exposição à API RESTful, capacitando os desenvolvedores a aproveitar todo o espectro de recursos LangChain de forma eficiente, estabelecendo um novo padrão para a implantação de aplicativos inteligentes no cenário digital acelerado de hoje. . LangChain oferece um método simples e conveniente de criar aplicativos usando seu que pode ser instalado com . Este pacote fornece uma interface que permite aos usuários criar facilmente novos aplicativos utilizando ou criando o seu próprio. langchain-cli biblioteca pip Modelos de aplicativos LangChain Nota: Todos os arquivos necessários estão localizados no repositório “blog-assets” do MinIO no diretório denominado “ ”. minio-langserve-deployment Para criar um novo aplicativo LangChain podemos começar com os seguintes comandos para criar um e instalar o pacote : ambiente virtual langchain-cli mkdir minio-langserve-testing cd minio-Langserve-testing python -m venv .myenv source .myenv/bin/activate pip install langchain-cli Para criar um novo aplicativo usando podemos digitar em nosso terminal, o seguinte comando é escrito para criar um novo diretório de aplicativo chamado . langchain-cli langchain my-app langchain app new my-app O aplicativo langchain criado com os comandos acima faz todo o trabalho pesado, criando um ambiente consistente para desenvolvimento. A estrutura de um novo aplicativo LangChain pronto para uso é assim: ./my-app ├── Dockerfile ├── README.md ├── app │ ├── __init__.py │ └── server.py ⇐ (This is where we will import our agent into) ├── packages ⇐ (This directory is where we will write our agent) │ └── README.md └── pyproject.toml Nas etapas a seguir, faremos alterações no aplicativo LangChain recém-criado ( ), escrevendo um novo arquivo chamado packages/agent.py e fazendo alterações em . my-app app/server.py Estes são os arquivos que discutiremos neste artigo: my-app/packages/agent.py my-app/app/server.py Desenvolvendo um agente LangChain MinIO para implantação com LangServe Para ilustrar a implantação de um agente LangChain integrado ao MinIO com LangServe, começaremos salvando o código da cadeia do agente em . agent.py Primeiro, vamos inicializar um que se conecta ao servidor público "play.min.io:443". Este arquivo eventualmente chamará do LangChain, permitindo-nos passá-lo para o wrapper do LangServe. minio_client agent_executor add_route Nota: Lendo a publicação anterior " Ferramenta MinIO Langchain " fornecerá informações valiosas sobre o desenvolvimento conjunto com LangChain e MinIO. Seguiremos uma abordagem conceitual semelhante, mas com lógica de ferramenta MinIO adicional. Para começar, abra o arquivo agent.py usando um editor de texto: sudo nano packages/agent.py No início do arquivo importe os pacotes necessários, como , , e : os io minio ChatOpenAI import os import io from minio import Minio from minio.error import S3Error from langchain_openai import ChatOpenAI os.environ["OPENAI_API_KEY"] = " >" # Initialize llm llm = ChatOpenAI(api_key=os.environ["OPENAI_API_KEY"]) # Initialize MinIO client minio_client = Minio('play.min.io:443', access_key='minioadmin', secret_key='minioadmin', secure=True) Neste trecho de código, importamos os pacotes necessários e inicializamos o modelo de linguagem ChatOpenAI com a chave de API OpenAI armazenada na variável de ambiente . Também inicializamos o minio_client fornecendo os detalhes de conexão necessários ao servidor público "play.min.io". OPENAI_API_KEY A seguir, vamos definir o bucket MinIO e criá-lo se ele não existir: # This variable will check if bucket exists bucket_name = "test" try: # Check if bucket exists if not minio_client.bucket_exists(bucket_name): # Create the bucket because it does not exist minio_client.make_bucket(bucket_name) print(f"Bucket '{bucket_name}' created successfully.") else: print(f"Bucket '{bucket_name}' already exists.") except S3Error as err: print(f"Error encountered: {err}") Aqui, definimos como “test” e verificamos se ele já existe usando o método . Se o bucket não existir, nós o criamos usando . Se o bucket já existir, imprimimos uma mensagem indicando isso. Também incluímos o tratamento de erros usando um bloco try-except para capturar e imprimir qualquer que possa ocorrer durante o processo. bucket_name minio_client.bucket_exists() minio_client.make_bucket() S3Error Com a configuração básica definida, podemos agora definir as funções da ferramenta MinIO e criar o executor do agente, que abordaremos nas próximas etapas. Usando o Function Decorator do LangChain para ferramentas de agente Langchain e Langserve fornecem uma abordagem semelhante para encapsular lógica e funcionalidade, permitindo que sejam perfeitamente integrados à lógica do agente e da cadeia. Isso é conseguido através do uso do decorador com uma documentação detalhada dentro da função definida, que marca as funções como componentes reutilizáveis que podem ser utilizados e interpretados pelo agente de IA. @tool Vamos dar uma olhada mais de perto nos exemplos de código fornecidos: from langchain.agents import tool @tool def upload_file_to_minio(bucket_name: str, object_name: str, data_bytes: bytes): """ Uploads a file to MinIO. Parameters: bucket_name (str): The name of the bucket. object_name (str): The name of the object to create in the bucket. data_bytes (bytes): The raw bytes of the file to upload. """ data_stream = io.BytesIO(data_bytes) minio_client.put_object(bucket_name, object_name, data_stream, length=len(data_bytes)) return f"File {object_name} uploaded successfully to bucket {bucket_name}." A função é decorada com , indicando que é um componente reutilizável. Ele recebe os parâmetros necessários para fazer upload de um arquivo para um bucket MinIO, como o nome do bucket, o nome do objeto e os bytes brutos do arquivo. A função utiliza o para realizar a operação de upload do arquivo e retorna uma mensagem de sucesso após a conclusão. upload_file_to_minio @tool minio_client @tool def download_file_from_minio(file_info): """ Custom function to download a file from MinIO. Expects file_info dict with 'bucket_name', 'object_name', and 'save_path' keys. 'save_path' should be the local path where the file will be saved. """ bucket_name = file_info['bucket_name'] object_name = file_info['object_name'] save_path = file_info['save_path'] minio_client.get_object(bucket_name, object_name, save_path) Da mesma forma, a função também está marcada com . Ele espera um dicionário contendo as informações necessárias para baixar um arquivo de um bucket MinIO, como o nome do bucket, o nome do objeto e o caminho local onde o arquivo deve ser salvo. A função usa para recuperar o objeto do bucket especificado e salvá-lo no caminho local designado. download_file_from_minio @tool file_info minio_client @tool def list_objects_in_minio_bucket(file_info): """ Custom function to list objects in a MinIO bucket. Expects file_info dict with 'bucket_name' key. Returns a list of dictionaries containing 'ObjectKey' and 'Size' keys. """ bucket_name = file_info['bucket_name'] response = minio_client.list_objects(bucket_name) return [{'ObjectKey': obj.object_name, 'Size': obj.size} for obj in response.items] A função , também decorada com é responsável por listar os objetos presentes em um bucket MinIO. Ele espera um dicionário com a chave . A função usa para recuperar a lista de objetos no bucket especificado e retorna uma lista de dicionários contendo a chave e o tamanho do objeto para cada objeto. list_objects_in_minio_bucket @tool file_info bucket_name minio_client Ao encapsular essas funcionalidades como ferramentas, Langchain e Langserve permitem que o agente de IA as incorpore perfeitamente em sua lógica e processo de tomada de decisão. O agente pode selecionar e executar de forma inteligente a ferramenta apropriada com base na tarefa em questão, aprimorando suas capacidades e permitindo interações mais complexas e dinâmicas com o sistema de armazenamento MinIO. Compreendendo o método executável do LangChain LangChain oferece uma infinidade de métodos para construção com lógica customizada, uma dessas abordagens é a de “ ”. Quanto à lógica demonstrativa acima, que é uma construção fornecida por LangChain que permite que funções sejam tratadas como unidades executáveis dentro da lógica do agente de IA. executáveis RunnableLambda from langchain_core.runnables import RunnableLambda upload_file_runnable = RunnableLambda(upload_file_to_minio) download_file_runnable = RunnableLambda(download_file_from_minio) list_objects_runnable = RunnableLambda(list_objects_in_minio_bucket) Ao envolver as funções da ferramenta com RunnableLambda, criamos instâncias executáveis ( , e ) que podem ser invocadas pelo agente durante sua execução. Esses executáveis encapsulam as funções da ferramenta correspondentes e fornecem uma interface uniforme para o agente interagir com eles. upload_file_runnable download_file_runnable list_objects_runnable tools = [upload_file_to_minio, download_file_from_minio, list_objects_in_minio_bucket] llm_with_tools = llm.bind_tools(tools) A lista de ferramentas contém as funções originais da ferramenta ( , e ), que servem como blocos de construção para os recursos do agente. A linha vincula as ferramentas ao modelo de linguagem ( ), estabelecendo uma conexão entre as capacidades de raciocínio do modelo e as funcionalidades específicas fornecidas pelas ferramentas. O resultante representa o modelo de linguagem aprimorado com o conhecimento e a capacidade de empregar as ferramentas vinculadas. upload_file_to_minio download_file_from_minio list_objects_in_minio_bucket llm.bind_tools(tools) llm llm_with_tools O uso de e a ligação de ferramentas ao modelo de linguagem demonstram a flexibilidade e extensibilidade de LangChain e LangServe na criação de agentes de IA poderosos e personalizáveis. Ao combinar o poder do modelo de linguagem com as funcionalidades específicas encapsuladas nas ferramentas, o agente de IA ganha a capacidade de realizar tarefas complexas, como fazer upload de arquivos para o MinIO, baixar arquivos do MinIO e listar objetos em um bucket do MinIO. RunnableLambda Escrevendo um modelo de prompt para orientar nosso agente Em seguida, mudamos nosso foco para o modelo de prompt que orienta o agente de IA na compreensão e resposta às entradas do usuário. Ele é definido usando o método , que recebe uma lista de mensagens representadas como tuplas contendo a função e o conteúdo da mensagem. ChatPromptTemplate.from_messages() from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder from langchain.agents.format_scratchpad.openai_tools import format_to_openai_tool_messages from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser from langchain_core.messages import AIMessage, HumanMessage prompt_template = ChatPromptTemplate.from_messages([ ("system", "You are a powerful assistant equipped with file management capabilities."), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]) O prompt consiste em três mensagens: Uma mensagem de “sistema” que define o contexto para o agente de IA como um assistente poderoso com recursos de gerenciamento de arquivos. Uma mensagem de "usuário" representando a entrada do usuário, usando o espaço reservado . {input} Um chamado "agent_scratchpad" para armazenar as etapas intermediárias e o processo de pensamento do agente. MessagesPlaceholder A função formata o scratchpad do agente em um formato compatível com as ferramentas da OpenAI, enquanto a classe OpenAIToolsAgentOutputParser analisa a resposta do modelo em um formato estruturado interpretável pelo agente. format_to_openai_tool_messages As classes e representam as mensagens trocadas entre o agente e o usuário, fornecendo uma forma padronizada de lidar com a comunicação dentro da lógica do agente. AIMessage HumanMessage Ao definir o modelo de prompt, fornecemos ao agente de IA uma estrutura e contexto claros para compreender e responder às entradas do usuário, utilizando o espaço reservado "agent_scratchpad" para acompanhar suas etapas intermediárias e processo de pensamento enquanto resolve a tarefa. Definindo o Agente com suas Ferramentas Finalmente, para completar nosso definimos nosso agente e criamos um AgentExecutor que pode ser importado e chamado de um script usando a função da biblioteca LangServe. agent.py server.py add_route Instanciamos os componentes necessários e os encadeamos para criar uma única variável de agente. agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_tool_messages(x["intermediate_steps"]), } | prompt_template | llm_with_tools | OpenAIToolsAgentOutputParser() ) O agente é definido usando uma combinação de dicionários e operações encadeadas. A chave de entrada extrai a entrada do usuário dos dados recebidos, enquanto a chave formata as etapas intermediárias do processo de pensamento do agente usando a função . O agente também incorpora o modelo de prompt ( ), o modelo de linguagem com ferramentas ( ) e o analisador de saída ( ). agent_scratchpad format_to_openai_tool_messages prompt_template llm_with_tools OpenAIToolsAgentOutputParser() Definindo um AgentExecutor para executar o agente Para criar um , fornecemos a ele o agente definido, as ferramentas disponíveis e definimos para saída detalhada. AgentExecutor verbose=True from langchain.agents import tool, AgentExecutor agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) O usa o agente e as ferramentas fornecidas para compreender a tarefa e selecionar a ferramenta apropriada com base na entrada do usuário. Em vez de ter prompts separados para cada ferramenta, o agente utiliza um único modelo de prompt que o orienta sobre como usar as ferramentas com base na entrada fornecida. O agente seleciona dinamicamente a ferramenta apropriada durante o processo de execução. AgentExecutor Definindo a rota LangServe com nosso AgentExecutor Configurar nosso aplicativo integrando-o ao LangServe fornece um caminho simplificado para implantar e gerenciar nossos aplicativos LangChain como APIs. FastAPI é escolhido por seu desempenho e facilidade de uso, suportando operações assíncronas e gerando automaticamente documentação de API. O , desenvolvido com FastAPI, enriquece isso simplificando a implantação de objetos LangChain como APIs REST, oferecendo middleware integrado para configurações CORS para garantir que nossa API possa ser chamada com segurança de diferentes domínios. Biblioteca LangServe Para demonstrações mais aprofundadas/de casos de uso, você pode explorar visitando o langchain-ai/langserve Repositório GitHub sob o diretório de exemplos . from fastapi import FastAPI app = FastAPI( title="MinIO Agent API", version="1.0", description="A conversational agent facilitating data storage and retrieval with MinIO", ) Para definir cabeçalhos CORS, podemos adicionar as seguintes linhas para aumentar nossa segurança: from fastapi.middleware.cors import CORSMiddleware # Set all CORS enabled origins app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], expose_headers=["*"], ) Implementando o Agente usando LangServe Agora que terminamos com podemos importá-lo e usar a função da biblioteca LangServe em nosso script . packages/agent.py add_route app/server.py from packages.agent import agent_executor from langserve import add_routes add_routes( app, agent_executor.with_types(input_type=Input, output_type=Output).with_config( {"run_name": "agent"} ), path=”/invoke” ) Chamando , adicionamos uma rota ao nosso aplicativo de servidor ( ) que mapeia o caminho para a função . Isso permite que o executor do agente seja chamado quando uma solicitação é feita ao endpoint . add_route(app, agent_executor(…), path="/invoke") app /invoke agent_executor() /invoke Com esta configuração, o servidor pode lidar com solicitações recebidas, passá-las ao executor do agente e retornar a resposta do agente ao cliente. O executor do agente utiliza o agente definido, que incorpora o modelo de prompt, o modelo de linguagem com ferramentas e o analisador de saída, para processar a entrada do usuário e gerar uma resposta apropriada com base nas ferramentas disponíveis. Iniciando o aplicativo LangServe via Uvicorn Para iniciar o aplicativo LangServe, empregamos Uvicorn como servidor ASGI, preparando o terreno para a execução de nosso aplicativo. Este trecho de código é fundamental porque ativa o servidor, especificando o host universal e a porta designada para os pontos de acesso do aplicativo. if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) Ao incorporar este bloco na entrada principal do aplicativo, garantimos que o Uvicorn assuma o comando quando o script for executado diretamente, ativando assim nosso aplicativo FastAPI em um host e porta predefinidos. Essa abordagem não apenas simplifica o processo de implantação, mas também marca uma entrada clara para a execução do aplicativo em um ambiente de desenvolvimento ou produção. Iniciando o aplicativo de servidor O código acima foi demonstrado em uma abordagem modular que inclui o uso da biblioteca “langchain-cli”, a criação de um novo aplicativo langchain e o salvamento da lógica da cadeia em enquanto a implementação FastAPI e LangServe é salva em . agent.py server.py Sendo esta a nossa etapa final, salvaremos o código do nosso aplicativo em para o propósito demonstrativo de construção de nosso aplicativo. server.py A maneira mais simples de executar nosso serviço é com: python server.py Este comando executará o aplicativo, retornando quaisquer logs ou mensagens de erro que ainda precisam ser depurados. Parque LangServe Na saída do python, os logs do LangServe identificam como o endpoint do aplicativo. Agora podemos visitar o playground WebUI, bem como a documentação automatizada de nossa API que está disponível visitando o caminho de nossa API; dando-nos uma abordagem simplificada para testar e configurar, incluindo o botão Experimente para cada um dos recursos de nossos aplicativos, bem como solicitações cURL predefinidas que podemos executar a partir da WebUI. /invoke/playground /docs Consequentemente, nosso agente LangChain integrado ao MinIO agora está habilmente transformado em uma API implantável, pronta para ser desenvolvida e estendida para usuários com funcionalidades que vão desde processamento em lote até interações em tempo real. Uso adicional da API LangServe Com o aplicativo LangServe instalado e funcionando, podemos usá-lo fora de nosso , direcionando nosso endpoint e agrupando-o no módulo do Langserve: server.py RemoteRunnable from langserve import RemoteRunnable remote_runnable = RemoteRunnable("http://localhost:8000/ /") Adicionar LangChain possui uma vasta gama de módulos em suas bibliotecas, apresentando um kit de ferramentas diversificado projetado para capacitar os desenvolvedores na construção de aplicativos sofisticados baseados em IA. Desde construções de cadeias complexas até a integração perfeita com vários modelos de IA, a arquitetura modular do LangChain facilita uma ampla gama de funcionalidades, permitindo a criação de soluções altamente personalizáveis e avançadas no domínio da IA e do aprendizado de máquina. Desenvolvendo pipelines de IA com LangServe LangServe não apenas desmistifica, mas simplifica significativamente o processo de implantação de aplicativos LangChain. Ao preencher a lacuna entre o desenvolvimento e a implantação, garante que aplicações inovadoras que aproveitam o MinIO e o LangChain possam passar rapidamente do conceito à realidade, prontas para serem integradas ao ecossistema mais amplo e aprimorarem as experiências do usuário. Através do desenvolvimento abordado em nossas explorações, vimos a integração perfeita do MinIO com é absolutamente possível, e como desempenha um papel fundamental na implantação dessas soluções avançadas. À medida que continuamos a navegar no cenário em evolução da IA e do ML, ferramentas como o LangServe continuarão a ser fundamentais para trazer tecnologias de ponta para a vanguarda do desenvolvimento de aplicações. LangChain LangServe Na MinIO, somos energizados pela criatividade e pelo potencial da comunidade de desenvolvedores durante esta era rica em tecnologia. Não há melhor momento para colaboração e troca de conhecimento. Estamos ansiosos para nos conectar com você! Junte-se a nós em nosso canal para continuar a conversa e alcançar novos patamares juntos. Folga MinIO