Spaces:
Sleeping
Sleeping
import gradio as gr | |
from crewai import Agent, Task, Crew, Process, LLM | |
from crewai_tools import LlamaIndexTool | |
from llama_index.core import StorageContext, load_index_from_storage | |
from llama_index.core.tools import QueryEngineTool, ToolMetadata | |
from llama_index.core.agent import ReActAgent | |
from llama_index.core import Settings | |
from llama_index.tools.tavily_research import TavilyToolSpec | |
from llama_index.llms.groq import Groq | |
from llama_index.embeddings.huggingface import HuggingFaceEmbedding | |
from llama_index.core.tools import FunctionTool | |
import os | |
from dotenv import load_dotenv | |
import requests | |
import arxiv | |
import requests | |
load_dotenv() | |
HF_TOKEN = os.getenv('HF_TOKEN') | |
groq = os.getenv('GROQ_API_KEY') | |
tavily_key = os.getenv('tavily') | |
nvidia = os.getenv('nvidia') | |
Settings.llm = Groq(model="llama3-groq-70b-8192-tool-use-preview", api_key=groq) | |
Settings.embed_model = HuggingFaceEmbedding(model_name="intfloat/multilingual-e5-large") | |
def consulta_artigos(titulo: str) -> str: | |
""" | |
Consulta os artigos na base de dados arXiv e retorna resultados formatados. | |
""" | |
busca = arxiv.Search( | |
query=titulo, | |
max_results=5, | |
sort_by=arxiv.SortCriterion.Relevance | |
) | |
resultados = [] | |
for resultado in busca.results(): | |
resultados.append(f"Título: {resultado.title}\n" | |
f"Resumo: {resultado.summary}\n" | |
f"Categoria: {resultado.primary_category}\n" | |
f"Link: {resultado.entry_id}\n") | |
return "\n\n".join(resultados) | |
ferramenta_artigos = FunctionTool.from_defaults(fn=consulta_artigos, name="consulta_artigos", description="Consulta os artigos na base de dados arXiv e retorna resultados formatados.") | |
tool = LlamaIndexTool.from_tool(ferramenta_artigos) | |
print(tavily_key) | |
tavily_tool = TavilyToolSpec(api_key=tavily_key) | |
tavily_tools = tavily_tool.to_tool_list() | |
tools = [LlamaIndexTool.from_tool(t) for t in tavily_tools] | |
storage_context = StorageContext.from_defaults( | |
persist_dir="./artigo" | |
) | |
artigo_index = load_index_from_storage(storage_context) | |
storage_context = StorageContext.from_defaults( | |
persist_dir="./livro" | |
) | |
livro_index = load_index_from_storage(storage_context) | |
artigo_engine = artigo_index.as_query_engine(similarity_top_k=3) | |
livro_engine = livro_index.as_query_engine(similarity_top_k=3) | |
query_engine_tools = [ | |
QueryEngineTool( | |
query_engine=artigo_engine, | |
metadata=ToolMetadata( | |
name="artigo_engine", | |
description=( | |
"Fornece informações sobre algoritmos de inteligência artificial nas redes sociais. " | |
"Use uma pergunta detalhada em texto simples como entrada para a ferramenta." | |
), | |
), | |
), | |
QueryEngineTool( | |
query_engine=livro_engine, | |
metadata=ToolMetadata( | |
name="livro_engine", | |
description=( | |
"Fornece informações sobre avanços e tendências sobre inteligência artificial. " | |
"Use uma pergunta detalhada em texto simples como entrada para a ferramenta." | |
), | |
), | |
), | |
] | |
llm = LLM( | |
model="nvidia_nim/meta/llama-3.3-70b-instruct", | |
api_key=nvidia | |
) | |
def baixar_pdf_arxiv(link): | |
""" | |
Baixa o PDF de um artigo do arXiv dado o link do artigo. | |
Args: | |
link (str): O link para o artigo no arXiv. | |
Returns: | |
str: O caminho do arquivo salvo ou uma mensagem de erro. | |
""" | |
try: | |
# Verifica se o link é do arXiv | |
if "arxiv.org" not in link: | |
return "O link fornecido não é um link válido do arXiv." | |
# Extrai o ID do artigo do link | |
artigo_id = link.split("/")[-1] | |
# Monta o link direto para o PDF | |
pdf_url = f"https://arxiv.org/pdf/{artigo_id}.pdf" | |
# Faz o download do PDF | |
response = requests.get(pdf_url, stream=True) | |
if response.status_code == 200: | |
nome_arquivo = f"artigo_{artigo_id}.pdf" | |
with open(nome_arquivo, "wb") as f: | |
for chunk in response.iter_content(chunk_size=1024): | |
f.write(chunk) | |
return f"PDF salvo como {nome_arquivo}" | |
else: | |
return f"Erro ao baixar o PDF. Código de status: {response.status_code}" | |
except Exception as e: | |
return f"Ocorreu um erro: {e}" | |
ferramenta_baixar = FunctionTool.from_defaults(fn=baixar_pdf_arxiv, name="baixa_artigos", description="Baixa o PDF de um artigo do arXiv dado o link do artigo.") | |
tool_baixar = LlamaIndexTool.from_tool(ferramenta_baixar) | |
def pesquisar_artigos(tema): | |
# Criação dos agentes com o tema dinâmico | |
agent = Agent( | |
role='Agente de pesquisa', | |
goal='Fornece artigos científicos sobre um assunto de interesse.', | |
backstory='Um agente expert em pesquisa científica que possui a habilidade de acessar e baixar artigos no arxiv', | |
tools=[tool, tool_baixar], | |
llm=llm | |
) | |
agent_web = Agent( | |
role='Agente de pesquisa por documentos na web', | |
goal='Fornece artigos científicos encontrados na web sobre um assunto de interesse.', | |
backstory='Um agente expert em pesquisa científica que possui a habilidade de buscar artigos na web', | |
tools=[*tools], | |
llm=llm | |
) | |
agente_verificacao = Agent( | |
role='Agente de pesquisa que verifica documentos', | |
goal='Fornece como saída apenas artigos científicos válidos', | |
backstory='Um agente expert em pesquisa científica', | |
tools=[*tools], | |
llm=llm | |
) | |
manager = Agent( | |
role="Gerente do projeto", | |
goal="Gerenciar a equipe com eficiência", | |
backstory="Gerente de projeto experiente que coordena os esforços da equipe", | |
allow_delegation=True, | |
llm=llm | |
) | |
# Criação das tasks usando o tema recebido como parâmetro | |
task = Task( | |
description=f"Busque artigos científicos no arxiv sobre {tema}.", | |
expected_output="5 artigos e seus respectivos links", | |
agent=agent | |
) | |
task1 = Task( | |
description=f"Busque artigos científicos sobre {tema}.", | |
expected_output="5 artigos e seus respectivos links", | |
agent=agent_web | |
) | |
task2 = Task( | |
description="Verifique se os artigos encontrados na web realmente são artigos científicos.", | |
expected_output="5 artigos e seus respectivos links", | |
agent=agente_verificacao | |
) | |
crew_hierarquica = Crew( | |
agents=[agent, agent_web, agente_verificacao], | |
tasks=[task, task1, task2], | |
manager_agent=manager, | |
process=Process.hierarchical, | |
verbose=1, | |
) | |
result = crew_hierarquica.kickoff() | |
return result | |
# Função para a segunda aba | |
def pergunta(query): | |
agente = ReActAgent.from_tools( | |
query_engine_tools, | |
verbose=True, | |
) | |
response = agente.chat(query) | |
return response | |
# Interface Gradio para a primeira aba | |
pesquisa_interface = gr.Interface( | |
fn=pesquisar_artigos, | |
inputs=gr.Textbox(label="Digite o tema para pesquisa"), | |
outputs=gr.Textbox(label="Resultados"), | |
title="👨🔬👩🔬 Pesquisador de Artigos Científicos", | |
description="Digite um tema para encontrar artigos científicos relacionados.", | |
theme=gr.themes.Glass() | |
) | |
# Interface Gradio para a segunda aba | |
hello_interface = gr.Interface( | |
fn=pergunta, | |
inputs=gr.Textbox(label="Faça sua pergunta"), | |
outputs=gr.Textbox(label="Saída"), | |
title="Perguntas sobre IA nas redes sociais", | |
description="Exemplo simples de uma segunda aba." | |
) | |
# Combinação das abas em um bloco de abas | |
with gr.Blocks(theme=gr.themes.Glass()) as app: | |
with gr.Tab("Pesquisa de Artigos"): | |
pesquisa_interface.render() | |
with gr.Tab("Consulta artigos"): | |
hello_interface.render() | |
# Iniciar a aplicação | |
app.launch() | |