Para criar um agente de estudo de uma IA para escrever um artigo

Nesta lição, criaremos uma agência de alta qualidade que pode escrever ensaios para os tópicos fornecidos. Este mentido seguiu o movimento formal do trabalho:

Preparação: Cria um quadro de ensaio.
Pesquisar: Retorna documentos apropriados que abusam.
Mão: Use a pesquisa inicial de desenho.
Reflexão: Desenvolvimento de desenvolvimento de desenvolvimento.

Refinamento existente: Para realizar mais pesquisas com base em críticas e revisar o artigo.

O agente usará o processo de exibição e revisão até que o número de desenvolvimento seja feito. Vamos entrar no início.

Configurando o ambiente

Começamos com variáveis naturais, incluindo as bibliotecas necessárias e as bibliotecas de importação:

pip install langgraph==0.2.53 langgraph-checkpoint==2.0.6 langgraph-sdk==0.1.36 langchain-groq langchain-community langgraph-checkpoint-sqlite==2.0.1 tavily-python

import os
os.environ['TAVILY_API_KEY'] = "your_tavily_key"
os.environ['GROQ_API_KEY'] = "your_groq_key"

from langgraph.graph import StateGraph, END
from typing import TypedDict, List
from langchain_core.messages import SystemMessage, HumanMessage

from langgraph.checkpoint.sqlite import SqliteSaver
import sqlite3

sqlite_conn = sqlite3.connect("checkpoints.sqlite",check_same_thread=False)
memory = SqliteSaver(sqlite_conn)

Definindo a condição do agente

O agente mantém as informações pessoais, incluindo:

Trabalhar: Exoge de exes
Editar: Um sistema produzido ou estrutura para o artigo
Rascunho: Rascunho do artigo
Crítica: Críticas e recomendações foram produzidas em um estado mostrado.
Contente: O conteúdo de pesquisa é emitido em resultados de pesquisa de Tavily

Número de revisão: O cálculo da quantidade de revisões que aconteceram até agora

class AgentState(TypedDict):
    task: str
    plan: str
    draft: str
    critique: str
    content: List[str]
    revision_number: int
    max_revisions: int

Inicia o modelo de idioma

Utilizamos o modelo de llama gratuito fornecido pela GROQ para produzir técnicas, rascunhos, críticas e questões de pesquisa.

from langchain_groq import ChatGroq

model = ChatGroq(model="Llama-3.3-70b-Specdec")

Definição de altura

Ele descreve o sistema encorajador para o fluxo de cada agente do agente (você pode brincar em torno disso, se quiser):

PLAN_PROMPT = """You are an expert writer tasked with creating an outline for an essay.
Generate a structured outline with key sections and relevant notes."""

WRITER_PROMPT = """You are an AI essay writer. Write a well-structured essay based on the given research.
Ensure clarity, coherence, and proper argumentation.

------

{content}"""

REFLECTION_PROMPT = """You are a teacher reviewing an essay draft.
Provide detailed critique and suggestions for improvement."""

RESEARCH_PLAN_PROMPT = """You are an AI researcher tasked with finding supporting information for an essay topic.
Generate up to 3 relevant search queries."""

RESEARCH_CRITIQUE_PROMPT = """You are an AI researcher refining an essay based on critique.
Generate up to 3 search queries to address identified weaknesses."""

Editar questões de pesquisa

Usamos o Pydantic para descrever a formação de questões de pesquisa. O Pydantic nos permite explicar a formação da liberação do LLM.

from pydantic import BaseModel

class Queries(BaseModel):
    queries: List[str]

Combinando à pesquisa de pesquisa

Como no tempo, usaremos os documentos relevantes por escrito do artigo de pesquisa.

from tavily import TavilyClient
import os

tavily = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

Implementação da IA

1. Planejando e feito

Cria uma estrutura de ensaio de acordo com o assunto fornecido.

def plan_node(state: AgentState):
    messages = [
        SystemMessage(content=PLAN_PROMPT),
        HumanMessage(content=state['task'])
    ]
    response = model.invoke(messages)
    return {"plan": response.content}

2. Plano de nó e dade

Cria perguntas de pesquisa e retorna documentos apropriados.

def research_plan_node(state: AgentState):
    queries = model.with_structured_output(Queries).invoke([
        SystemMessage(content=RESEARCH_PLAN_PROMPT),
        HumanMessage(content=state['task'])
    ])
    content = state['content'] if 'content' in state else []
    for q in queries.queries:
        response = tavily.search(query=q, max_results=2)
        for r in response['results']:
            content.append(r['content'])
    return {"content": content}

3. Escrever e de

Use o conteúdo da pesquisa para produzir o início do primeiro ensaio.

def generation_node(state: AgentState):
    content = "nn".join(state['content'] or [])
    user_message = HumanMessage(content=f"{state['task']}nnHere is my plan:nn{state['plan']}")
    messages = [
        SystemMessage(content=WRITER_PROMPT.format(content=content)),
        user_message
    ]
    response = model.invoke(messages)
    return {"draft": response.content, "revision_number": state.get("revision_number", 1) + 1}

4. Nó para meditação

Cria críticas ao rascunho atual.

def reflection_node(state: AgentState):
    messages = [
        SystemMessage(content=REFLECTION_PROMPT),
        HumanMessage(content=state['draft'])
    ]
    response = model.invoke(messages)
    return {"critique": response.content}

5. Avaliação de críticas e longa

Cria algumas perguntas de pesquisa baseadas em críticas.

def research_critique_node(state: AgentState):
    queries = model.with_structured_output(Queries).invoke([
        SystemMessage(content=RESEARCH_CRITIQUE_PROMPT),
        HumanMessage(content=state['critique'])
    ])
    content = state['content'] or []
    for q in queries.queries:
        response = tavily.search(query=q, max_results=2)
        for r in response['results']:
            content.append(r['content'])
    return {"content": content}

Definindo o estado de item

Utilizamos a quantidade de iterações como uma decisão de determinar se queremos continuar revisando ou nos livrando do loop. Portanto, o agente continua atualizando o ensaio até que as principais atualizações sejam alcançadas.

def should_continue(state):
    if state["revision_number"] > state["max_revisions"]:
        return END
    return "reflect"

Construindo um trabalho de trabalho

We define a state graph to connect different nodes in the workflow.
builder = StateGraph(AgentState)

builder.add_node("planner", plan_node)
builder.add_node("generate", generation_node)
builder.add_node("reflect", reflection_node)
builder.add_node("research_plan", research_plan_node)
builder.add_node("research_critique", research_critique_node)

builder.set_entry_point("planner")

builder.add_conditional_edges("generate", should_continue, {END: END, "reflect": "reflect"})

builder.add_edge("planner", "research_plan")
builder.add_edge("research_plan", "generate")
builder.add_edge("reflect", "research_critique")
builder.add_edge("research_critique", "generate")

graph = builder.compile(checkpointer=memory)

Podemos imaginar o gráfico usando:

#from IPython.display import Image
#Image(graph.get_graph().draw_mermaid_png())

Autor de redação da AI

thread = {"configurable": {"thread_id": "1"}}
for s in graph.stream({
    'task': "What is the difference between LangChain and LangSmith",
    "max_revisions": 2,
    "revision_number": 1,
}, thread):
    print(s)

E somos feitos, agora continue examinando diferentes perguntas e brinquem com ela. Neste estudo, abordamos todo o processo de construção de uma pesquisa poderosa feita com um agente de redação. Agora você pode tentar aparecer em diferentes recursos de pesquisa e eficiência para melhorar a operação. Aqui estão outras melhorias que você pode tentar:

Construa uma GUI para uma melhor visão da operação do agente
Melhore o status final da renovação do número de vezes para terminar quando estiver satisfeito com os parentes.
Adicione suporte diretamente ao PDFS

Referências:

(Deeplecceaning.ai)

Weneet Kumar é estudante de um consultor em Marktechpost. Atualmente, ele perseguiu seu BS do Instituto Indiano de Tecnologia (IIT), Kanpur. Ele é um entusiasmo de aprendizado de máquina. Ela é apaixonada pela pesquisa recente e raiva na aprendizagem mais profunda, na ideia de computador e nos campos relacionados.

✅ [Recommended] Junte -se ao nosso canal de telégrafo

Source link