PocketFlow: uma estrutura minimalista para o desenvolvimento de aplicativos de IA em 100 linhas de código

Introdução geral

O PocketFlow é uma estrutura leve de desenvolvimento de aplicativos de IA com apenas 100 linhas de código, desenvolvida pela equipe da The-Pocket e de código aberto no GitHub. Ele busca um design minimalista, o código principal é controlado em 100 linhas, não há dependências externas e não há vínculos com fornecedores. Os desenvolvedores podem usá-lo para criar rapidamente aplicativos de IA, suporte para várias inteligências, fluxo de trabalho, geração de aumento de recuperação (RAG) e outras funções. Seu destaque é o "Agentic Coding", ou seja, permite que as inteligências de IA (como o Cursor O PocketFlow parte da estrutura gráfica mais básica e usa a menor quantidade de código para obter uma funcionalidade avançada, o que o torna ideal para indivíduos ou equipes que precisam desenvolver rapidamente aplicativos de IA.

Devido à quantidade relativamente pequena de código, o projeto também fornece um arquivo de configuração .cursorrules que automatiza a gravação de aplicativos de corpo inteligente no Cursor.

Lista de funções

• Apenas 100 linhas de código principalRacionalizado para 100 linhas, fácil de ler e alterar.
• Estrutura baseada em gráficosDefinição de tarefas de IA em termos de nós e conexões.
• Suporte de inteligência múltiplaInteligência de IA múltipla: várias inteligências de IA podem colaborar em tarefas.
• Fluxo de trabalho incorporadoDivisão de tarefas e ordem de execução em um relance.
• Geração de aumento de recuperação (RAG)Melhorar a qualidade dos resultados com a incorporação de dados externos.
• Autoprogramação de IA (Codificação Agêntica)IA: a IA pode escrever seu próprio código e economizar tempo.
• projeto de dependência zeroNão são necessárias bibliotecas adicionais, basta executá-lo.
• Compatível com qualquer LLMQualquer modelo de linguagem grande pode ser acessado.

Usando a Ajuda

Processo de instalação

A instalação do PocketFlow é muito simples e não exige configuração complexa do ambiente. Abaixo estão duas maneiras de instalar o PocketFlow:

Método 1: Instalação via pip

1. Abra uma ferramenta de linha de comando (CMD para Windows, Terminal para Mac).
2. Digite o comando:pip install pocketflowe, em seguida, pressione Enter.
3. O processo de instalação leva apenas alguns segundos e está pronto para uso quando concluído.
4. Verifique a instalação: na linha de comando, digite python -c "import pocketflow; print(pocketflow.__version__)"Se o número da versão for exibido, isso significa sucesso.

Método 2: Copiar diretamente o código-fonte

1. Abra seu navegador e acesse https://github.com/The-Pocket/PocketFlow.
2. Clique no botão "Code" (Código) no canto superior direito e selecione "Download ZIP" (Baixar ZIP) para fazer o download do código-fonte.
3. Descompacte o arquivo e localize o arquivo pocketflow/__init__.py(Isso representa 100 linhas de código principal).
4. Copie esse arquivo para a pasta do seu projeto.
5. Importar no código Python:importar pocketflowA seguir, um exemplo de como começar.

Como usar os principais recursos

Em sua essência, o PocketFlow é uma estrutura baseada em gráficos que organiza tarefas de IA por meio de nós e conexões (fluxo). Veja como ele funciona:

1. criação de fluxos de trabalho básicos

• mover::
  1. Crie um novo arquivo Python como test_flow.py.
  2. Digite o seguinte código:

     importar pocketflow
     flow = pocketflow.Flow()
     flow.add_node("hello", lambda x: print("Hello, PocketFlow!"))
     flow.run()
     

  3. Execute-o na linha de comando:python test_flow.py.
  4. A tela exibirá "Hello PocketFlow!" (Olá, PocketFlow!).
• instruçõesFluxo de trabalho simples: Este é um fluxo de trabalho simples que contém um nó que imprime mensagens.

2. uso de funções de inteligência múltipla

• mover::
  1. Modifique o código para incluir inteligências múltiplas:

     importar pocketflow
     flow = pocketflow.Flow()
     flow.add_node("agent1", lambda x: "Intelligence 1 says: Hello")
     flow.add_node("agent2", lambda x: f "A inteligência 2 responde: {x}, você também")
     flow.connect("agent1", "agent2")
     resultado = flow.run()
     print(result)
     

  2. Quando executado, ele gera o diálogo entre as inteligências.
• instruções::conectar O método conecta dois nós e os dados fluem do "agente1" para o "agente2".

3. adição da funcionalidade RAG

• mover::
  1. Criação de um arquivo de texto info.txtescreva algo como "PocketFlow é uma estrutura de IA leve".
  2. Modificar o código:

     importar pocketflow
     flow = pocketflow.Flow()
     def get_data(x).
     with open("info.txt", "r", encoding="utf-8") as f: return f.read().
     return f.read()
     flow.add_node("retrieve", get_data)
     flow.add_node("generate", lambda x: f "Gerar resultado: {x}")
     flow.connect("retrieve", "generate")
     resultado = flow.run()
     print(result)
     

  3. Após a execução, o conteúdo do arquivo e os resultados gerados são exibidos.
• instruçõesO RAG lê os dados externos por meio do nó "retrieve" e os passa para o nó "generate" para processamento.

4. uso de codificação agêntica (autoprogramação de IA)

• mover::
  1. Instale uma ferramenta que ofereça suporte à geração de código, como o Cursor AI.
  2. Digite o requisito no Cursor AI: "Write a program that calculates the sum of 1 to 10 using PocketFlow" (Escreva um programa que calcule a soma de 1 a 10 usando o PocketFlow).
  3. A IA pode gerar:

     importar pocketflow
     flow = pocketflow.Flow()
     flow.add_node("numbers", lambda x: list(range(1, 11)))
     flow.add_node("sum", lambda x: sum(x))
     flow.connect("numbers", "sum")
     resultado = flow.run()
     print(f "A soma é: {result}")
     

  4. Após a execução, o resultado é "A soma é: 55".
• instruçõesA IA gera o código do PocketFlow diretamente, os desenvolvedores apenas copiam e executam.

5. acesso a LLM externo

• mover::
  1. Supondo que você tenha a chave da API da OpenAI, modifique o código:

     importar pocketflow
     from openai import OpenAI
     cliente = OpenAI(api_key="sua chave de API")
     flow = pocketflow.Flow()
     flow.add_node("ask", lambda x: client.chat.completions.create(
     model="gpt-3.5-turbo",
     messages=[{"role": "user", "content": "hello"}]
     ).choices[0].message.content)
     resultado = flow.run()
     print(result)
     

  2. Quando executado, ele produzirá as respostas do modelo.
• instruçõesO PocketFlow não está vinculado a nenhum LLM e você pode acessá-lo livremente.

Resumo do processo de operação

1. Instale o PocketFlow (usando pip ou copiando o código-fonte).
2. Crie um novo arquivo Python, importe fluxo de bolso.
3. despesa ou gasto Fluxo() Crie fluxos de trabalho, adicione nós e conexões.
4. invocações executar() Executar tarefas e verificar resultados.
5. Ajuste a funcionalidade do nó para incluir inteligências ou RAGs, conforme necessário.

advertência

• Recomenda-se a versão 3.6 ou superior do Python.
• Se estiver usando um LLM externo, você precisará configurar a API e a rede.
• Para obter mais exemplos e uso, consulte a documentação oficial em https://the-pocket.github.io/PocketFlow/.

cenário do aplicativo

1. Validação rápida de ideias de IA
   Se você deseja criar um autoresponder, prototipe-o em minutos com o PocketFlow.
2. Aprenda o desenvolvimento de IA
   Estudantes ou novatos podem praticar com ele porque o código é simples e lógico.
3. Automação de pequenas tarefas
   Por exemplo, se você quiser resumir um documento ou gerar um e-mail, o PocketFlow pode fazer isso rapidamente.
4. Desenvolvimento do trabalho em equipe
   Várias pessoas podem usá-lo para dividir o design dos nós e criar aplicativos rapidamente.

QA

1. Qual é a diferença entre o PocketFlow e outras estruturas?
   Ele tem apenas 100 linhas de código, não tem dependências e é mais leve do que outras estruturas (como as 400.000 linhas do LangChain).
2. Preciso de ferramentas adicionais para a autoprogramação de IA?
   Sim, é recomendável usar o Cursor AI ou uma ferramenta semelhante com ele.
3. Ele está disponível comercialmente?
   Sim, ele é de código aberto, consulte a página do GitHub para obter a licença exata.