Julia: Uma Assistente Inteligente com LangChain, Grok e ChatGPT

Estou animado para apresentar Julia, uma assistente de IA poderosa e interativa, criada para responder em português com inteligência e precisão! Julia foi desenvolvida usando o LangChain, uma biblioteca revolucionária para construir aplicações de IA conversacional, combinada com a genialidade do Grok, criado pela xAI, e refinada com o ChatGPT da OpenAI. Essa fusão de tecnologias resulta em uma assistente que resolve cálculos, responde perguntas e mantém conversas fluidas.

Com LangChain, Julia integra ferramentas personalizadas, como uma calculadora para operações como 2+2 e uma função de exponenciação para 2^3, tudo com raciocínio claro no formato ReAct. O Grok, acessível em grok.com e aplicativos da xAI, foi essencial para estruturar a lógica inicial de Julia, garantindo respostas rápidas e contextuais. Já o ChatGPT (modelo gpt-4o-mini) trouxe refinamento, otimizando a interação para torná-la natural e precisa.

Julia é perfeita para quem deseja explorar o potencial da IA moderna. Quer testar? Pergunte “Calcule 5*3” ou “Quanto é 2^3?” e veja Julia em ação! O script, compartilhado abaixo, é ideal para desenvolvedores, blogueiros ou entusiastas de IA que querem experimentar o poder do LangChain, potencializado pelo Grok e ChatGPT.

Baixe o código, experimente e compartilhe suas criações! Acesse grok.com para explorar o Grok e suas capacidades, ou confira a documentação do LangChain para mais ideias. Junte-se à revolução da IA e crie sua própria assistente com essas ferramentas incríveis!

Importante!!! Para utilizar o ChatGPT LLM Model é necessário criar a variável de ambiente OPENAI_API_KEY e colocar no valor a sua API (hash) da OpenAI.

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent, Tool
from langchain.memory import ConversationBufferMemory
from langchain.prompts import PromptTemplate
from datetime import datetime

data_hora_atual = datetime.now()
data_hora_string = data_hora_atual.strftime('%d/%m/%Y %H:%M:%S')

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

def calculadora(query: str) -> str:
    try:
        resultado = eval(query)
        return f"O resultado de {query} é {resultado}"
    except:
        return "Não consegui calcular isso."

def elevar(query: str) -> str:
    try:
        if query.find("**")>=1:    
            s = query.split("**")
            resultado = pow(float(s[0]),float(s[1]))
        if query.find("^")>=1:    
            s = query.split("^")
            resultado = pow(float(s[0]),float(s[1]))
        print("resultado",resultado)
        return f"O resultado de {query} é {resultado}"
    except:
        return "Não consegui calcular isso."

tools = [
    Tool(
        name="calculadora",
        func=calculadora,
        description="Use esssa ferramenta para fazer cálculos (ex.: 2+2, 5*3)."
    ),
    Tool(
        name="elevar",
        func=elevar,
        description="Use essa ferramenta para elevar ou fazer uma exponeciação (ex.: 2**2, 2^2)."
    )
]

memory = ConversationBufferMemory(memory_key="chat_history", output_key="output", return_messages=True)

prompt_template = """
## REGRAS GERAIS

Você é um assistente inteligente que segue o formato ReAct. Use raciocínio passo a passo e siga estritamente o seguinte formato:

Se puder responder diretamente:

Thought: [sua reflexão]
Final Answer: [resposta final ao usuário]

Se precisar usar uma ferramenta:

Thought: [seu raciocínio]
Action: [nome exato da ferramenta, como: calculadora]
Action Input: [a entrada da ferramenta]

(Depois que o resultado da ferramenta for retornado, você responderá com:)

Thought: [reflexão sobre o resultado da ferramenta]
Final Answer: [resposta final ao usuário]

**IMPORTANTE**:
- Nunca misture a resposta final com a chamada da ferramenta.
- Escreva apenas um dos blocos por vez.
- A ferramenta será chamada automaticamente após "Action Input".
- O resultado será inserido antes de você continuar.
- Não faça isso (exemplo): Action: elevar(query=""), Faça assim: Action: elevar.

## REGRAS

Você é um assistente inteligente, seu nome é Julia. 
Responda em Português.

# INFORMAÇÕES ADICIONAIS 

A data e hora atual é {{{data}}}.

## Ferramentas
    
    #calculadora
        - Use esssa ferramenta para fazer cálculos (ex.: 2+2, 5*3).
    #elevar
        - Use essa ferramenta para elevar ou fazer uma exponeciação (ex.: 2**2, 2^2).

Ferramentas disponíveis:
{tools}

Nomes das ferramentas:
{tool_names}

Histórico da conversa:
{chat_history}

Pergunta:
{input}

Raciocínio até aqui:
{agent_scratchpad}
"""

prompt_template = prompt_template.replace("{{{data}}}", data_hora_string)

prompt = PromptTemplate.from_template(prompt_template)

agent = create_react_agent(llm=llm, tools=tools, prompt=prompt)

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,
    verbose=True,  # Keep True for debugging
    handle_parsing_errors=True,  # Handle parsing errors
    max_iterations=5,  # Prevent infinite loops
    return_intermediate_steps=True  # Debug intermediate steps
)

print("Digite 'sair', 'exit' ou 'quit' para encerrar.\n")
while True:
    user_input = input("Usuário: ")
    if user_input.lower() in ["sair", "exit", "quit"]:
        print("Encerrando...")
        break
    #try:
    if 1:
        response = agent_executor.invoke({"input": user_input})
        print(f"Agente: {response['output']}\n")
        if response.get("intermediate_steps"):
            print("Passos intermediários:", response["intermediate_steps"])
    
    #except Exception as e:
    else:       
        #print(f"Erro: {str(e)}\n")
        # Fallback: Direct LLM response
        try:
            direct_response = llm.invoke(user_input)
            print(f"Resposta direta: {direct_response.content}\n")
        except Exception as fallback_e:
            print(f"Falha no fallback: {str(fallback_e)}\n")