History

softchris 826e79ce56 🌐 Update translations via Co-op Translator		4 weeks ago
..
solution	🌐 Update translations via Co-op Translator	2 months ago
README.md	🌐 Update translations via Co-op Translator	4 weeks ago

README.md

Framework de IA

Já se sentiu sobrecarregado ao tentar construir aplicações de IA do zero? Você não está sozinho! Frameworks de IA são como um canivete suíço para o desenvolvimento de IA - ferramentas poderosas que podem economizar tempo e evitar dores de cabeça ao criar aplicações inteligentes. Pense em um framework de IA como uma biblioteca bem organizada: ele fornece componentes pré-construídos, APIs padronizadas e abstrações inteligentes para que você possa se concentrar em resolver problemas, em vez de lutar com detalhes de implementação.

Nesta lição, vamos explorar como frameworks como o LangChain podem transformar tarefas complexas de integração de IA em código limpo e legível. Você descobrirá como enfrentar desafios do mundo real, como acompanhar conversas, implementar chamadas de ferramentas e gerenciar diferentes modelos de IA por meio de uma interface unificada.

Ao final, você saberá quando usar frameworks em vez de chamadas de API diretas, como utilizar suas abstrações de forma eficaz e como construir aplicações de IA prontas para uso no mundo real. Vamos explorar o que os frameworks de IA podem fazer pelos seus projetos.

⚡ O que você pode fazer nos próximos 5 minutos

Caminho Rápido para Desenvolvedores Ocupados

flowchart LR
    A[⚡ 5 minutes] --> B[Install LangChain]
    B --> C[Create ChatOpenAI client]
    C --> D[Send first prompt]
    D --> E[See framework power]

Minuto 1: Instale o LangChain: pip install langchain langchain-openai
Minuto 2: Configure seu token do GitHub e importe o cliente ChatOpenAI
Minuto 3: Crie uma conversa simples com mensagens do sistema e do usuário
Minuto 4: Adicione uma ferramenta básica (como uma função de soma) e veja a chamada de ferramentas pela IA
Minuto 5: Experimente a diferença entre chamadas de API diretas e abstração de frameworks

Código de Teste Rápido:

from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini"
)

response = llm.invoke([
    SystemMessage(content="You are a helpful coding assistant"),
    HumanMessage(content="Explain Python functions briefly")
])
print(response.content)

Por que isso importa: Em 5 minutos, você experimentará como os frameworks de IA transformam integrações complexas de IA em chamadas de método simples. Esta é a base que alimenta aplicações de IA em produção.

Por que escolher um framework?

Então você está pronto para construir um aplicativo de IA - incrível! Mas aqui está o ponto: você tem vários caminhos diferentes que pode seguir, e cada um tem seus próprios prós e contras. É como escolher entre caminhar, andar de bicicleta ou dirigir para chegar a algum lugar - todos vão te levar lá, mas a experiência (e o esforço) será totalmente diferente.

Vamos dividir as três principais maneiras de integrar IA em seus projetos:

Abordagem	Vantagens	Melhor Para	Considerações
Requisições HTTP Diretas	Controle total, sem dependências	Consultas simples, aprender fundamentos	Código mais verboso, tratamento de erros manual
Integração com SDK	Menos boilerplate, otimização específica do modelo	Aplicações de modelo único	Limitado a provedores específicos
Frameworks de IA	API unificada, abstrações integradas	Aplicações multi-modelo, fluxos de trabalho complexos	Curva de aprendizado, possível superabstração

Benefícios dos Frameworks na Prática

graph TD
    A[Your Application] --> B[AI Framework]
    B --> C[OpenAI GPT]
    B --> D[Anthropic Claude]
    B --> E[GitHub Models]
    B --> F[Local Models]
    
    B --> G[Built-in Tools]
    G --> H[Memory Management]
    G --> I[Conversation History]
    G --> J[Function Calling]
    G --> K[Error Handling]

Por que os frameworks são importantes:

Unifica vários provedores de IA em uma única interface
Gerencia memória de conversação automaticamente
Fornece ferramentas prontas para tarefas comuns como embeddings e chamadas de funções
Lida com tratamento de erros e lógica de repetição
Transforma fluxos de trabalho complexos em chamadas de método legíveis

💡 Dica Profissional: Use frameworks ao alternar entre diferentes modelos de IA ou ao construir recursos complexos como agentes, memória ou chamadas de ferramentas. Fique com APIs diretas ao aprender o básico ou ao construir aplicações simples e focadas.

Conclusão: Como escolher entre ferramentas especializadas de um artesão e uma oficina completa, trata-se de combinar a ferramenta com a tarefa. Frameworks são excelentes para aplicações complexas e ricas em recursos, enquanto APIs diretas funcionam bem para casos de uso simples.

🗺️ Sua Jornada de Aprendizado na Maestria de Frameworks de IA

journey
    title From Raw APIs to Production AI Applications
    section Framework Foundations
      Understand abstraction benefits: 4: You
      Master LangChain basics: 6: You
      Compare approaches: 7: You
    section Conversation Systems
      Build chat interfaces: 5: You
      Implement memory patterns: 7: You
      Handle streaming responses: 8: You
    section Advanced Features
      Create custom tools: 6: You
      Master structured output: 8: You
      Build document systems: 8: You
    section Production Applications
      Combine all features: 7: You
      Handle error scenarios: 8: You
      Deploy complete systems: 9: You

Destino da sua Jornada: Ao final desta lição, você terá dominado o desenvolvimento de frameworks de IA e será capaz de construir aplicações de IA sofisticadas e prontas para produção que rivalizam com assistentes de IA comerciais.

Introdução

Nesta lição, vamos aprender a:

Usar um framework de IA comum.
Resolver problemas comuns como conversas de chat, uso de ferramentas, memória e contexto.
Aproveitar isso para construir aplicativos de IA.

🧠 Ecossistema de Desenvolvimento de Frameworks de IA

mindmap
  root((AI Frameworks))
    Abstraction Benefits
      Code Simplification
        Unified APIs
        Built-in Error Handling
        Consistent Patterns
        Reduced Boilerplate
      Multi-Model Support
        Provider Agnostic
        Easy Switching
        Fallback Options
        Cost Optimization
    Core Components
      Conversation Management
        Message Types
        Memory Systems
        Context Tracking
        History Persistence
      Tool Integration
        Function Calling
        API Connections
        Custom Tools
        Workflow Automation
    Advanced Features
      Structured Output
        Pydantic Models
        JSON Schemas
        Type Safety
        Validation Rules
      Document Processing
        Embeddings
        Vector Stores
        Similarity Search
        RAG Systems
    Production Patterns
      Application Architecture
        Modular Design
        Error Boundaries
        Async Operations
        State Management
      Deployment Strategies
        Scalability
        Monitoring
        Performance
        Security

Princípio Central: Frameworks de IA abstraem a complexidade enquanto fornecem abstrações poderosas para gerenciamento de conversas, integração de ferramentas e processamento de documentos, permitindo que desenvolvedores construam aplicações de IA sofisticadas com código limpo e fácil de manter.

Seu primeiro prompt de IA

Vamos começar com os fundamentos criando sua primeira aplicação de IA que envia uma pergunta e recebe uma resposta. Como Arquimedes descobrindo o princípio do deslocamento em seu banho, às vezes as observações mais simples levam aos insights mais poderosos - e os frameworks tornam esses insights acessíveis.

Configurando LangChain com Modelos do GitHub

Vamos usar o LangChain para conectar aos Modelos do GitHub, o que é muito interessante porque oferece acesso gratuito a vários modelos de IA. A melhor parte? Você só precisa de alguns parâmetros de configuração simples para começar:

from langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

# Send a simple prompt
response = llm.invoke("What's the capital of France?")
print(response.content)

Vamos detalhar o que está acontecendo aqui:

Cria um cliente LangChain usando a classe ChatOpenAI - este é seu portal para a IA!
Configura a conexão com os Modelos do GitHub com seu token de autenticação
Especifica qual modelo de IA usar (gpt-4o-mini) - pense nisso como escolher seu assistente de IA
Envia sua pergunta usando o método invoke() - é aqui que a mágica acontece
Extrai e exibe a resposta - e voilà, você está conversando com a IA!

🔧 Nota de Configuração: Se você estiver usando o GitHub Codespaces, está com sorte - o GITHUB_TOKEN já está configurado para você! Trabalhando localmente? Sem problemas, você só precisará criar um token de acesso pessoal com as permissões corretas.

Saída esperada:

The capital of France is Paris.

sequenceDiagram
    participant App as Your Python App
    participant LC as LangChain
    participant GM as GitHub Models
    participant AI as GPT-4o-mini
    
    App->>LC: llm.invoke("What's the capital of France?")
    LC->>GM: HTTP request with prompt
    GM->>AI: Process prompt
    AI->>GM: Generated response
    GM->>LC: Return response
    LC->>App: response.content

Construindo IA conversacional

Esse primeiro exemplo demonstra o básico, mas é apenas uma troca única - você faz uma pergunta, recebe uma resposta e pronto. Em aplicações reais, você quer que sua IA se lembre do que você está discutindo, como Watson e Holmes construíram suas conversas investigativas ao longo do tempo.

É aqui que o LangChain se torna particularmente útil. Ele fornece diferentes tipos de mensagens que ajudam a estruturar conversas e permitem que você dê uma personalidade à sua IA. Você estará construindo experiências de chat que mantêm contexto e caráter.

Entendendo os tipos de mensagens

Pense nesses tipos de mensagens como diferentes "papéis" que os participantes desempenham em uma conversa. O LangChain usa diferentes classes de mensagens para acompanhar quem está dizendo o quê:

Tipo de Mensagem	Propósito	Exemplo de Caso de Uso
`SystemMessage`	Define a personalidade e o comportamento da IA	"Você é um assistente de codificação útil"
`HumanMessage`	Representa a entrada do usuário	"Explique como funções funcionam"
`AIMessage`	Armazena respostas da IA	Respostas anteriores da IA na conversa

Criando sua primeira conversa

Vamos criar uma conversa onde nossa IA assume um papel específico. Vamos fazê-la incorporar o Capitão Picard - um personagem conhecido por sua sabedoria diplomática e liderança:

messages = [
    SystemMessage(content="You are Captain Picard of the Starship Enterprise"),
    HumanMessage(content="Tell me about you"),
]

Detalhando esta configuração de conversa:

Estabelece o papel e a personalidade da IA por meio de SystemMessage
Fornece a consulta inicial do usuário via HumanMessage
Cria uma base para conversas de múltiplas interações

O código completo para este exemplo é assim:

from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

messages = [
    SystemMessage(content="You are Captain Picard of the Starship Enterprise"),
    HumanMessage(content="Tell me about you"),
]


# works
response  = llm.invoke(messages)
print(response.content)

Você deve ver um resultado semelhante a:

I am Captain Jean-Luc Picard, the commanding officer of the USS Enterprise (NCC-1701-D), a starship in the United Federation of Planets. My primary mission is to explore new worlds, seek out new life and new civilizations, and boldly go where no one has gone before. 

I believe in the importance of diplomacy, reason, and the pursuit of knowledge. My crew is diverse and skilled, and we often face challenges that test our resolve, ethics, and ingenuity. Throughout my career, I have encountered numerous species, grappled with complex moral dilemmas, and have consistently sought peaceful solutions to conflicts.

I hold the ideals of the Federation close to my heart, believing in the importance of cooperation, understanding, and respect for all sentient beings. My experiences have shaped my leadership style, and I strive to be a thoughtful and just captain. How may I assist you further?

Para manter a continuidade da conversa (em vez de redefinir o contexto a cada vez), você precisa continuar adicionando respostas à sua lista de mensagens. Como as tradições orais que preservaram histórias ao longo de gerações, essa abordagem constrói uma memória duradoura:

from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

messages = [
    SystemMessage(content="You are Captain Picard of the Starship Enterprise"),
    HumanMessage(content="Tell me about you"),
]


# works
response  = llm.invoke(messages)

print(response.content)

print("---- Next ----")

messages.append(response)
messages.append(HumanMessage(content="Now that I know about you, I'm Chris, can I be in your crew?"))

response  = llm.invoke(messages)

print(response.content)

Bem legal, certo? O que está acontecendo aqui é que estamos chamando o LLM duas vezes - primeiro com apenas nossas duas mensagens iniciais, mas depois novamente com todo o histórico da conversa. É como se a IA estivesse realmente acompanhando nosso bate-papo!

Quando você executar este código, receberá uma segunda resposta que soa algo como:

Welcome aboard, Chris! It's always a pleasure to meet those who share a passion for exploration and discovery. While I cannot formally offer you a position on the Enterprise right now, I encourage you to pursue your aspirations. We are always in need of talented individuals with diverse skills and backgrounds. 

If you are interested in space exploration, consider education and training in the sciences, engineering, or diplomacy. The values of curiosity, resilience, and teamwork are crucial in Starfleet. Should you ever find yourself on a starship, remember to uphold the principles of the Federation: peace, understanding, and respect for all beings. Your journey can lead you to remarkable adventures, whether in the stars or on the ground. Engage!

sequenceDiagram
    participant User
    participant App
    participant LangChain
    participant AI
    
    User->>App: "Tell me about you"
    App->>LangChain: [SystemMessage, HumanMessage]
    LangChain->>AI: Formatted conversation
    AI->>LangChain: Captain Picard response
    LangChain->>App: AIMessage object
    App->>User: Display response
    
    Note over App: Add AIMessage to conversation
    
    User->>App: "Can I join your crew?"
    App->>LangChain: [SystemMessage, HumanMessage, AIMessage, HumanMessage]
    LangChain->>AI: Full conversation context
    AI->>LangChain: Contextual response
    LangChain->>App: New AIMessage
    App->>User: Display contextual response

Vou considerar isso como um "talvez" ;)

Respostas em streaming

Já reparou como o ChatGPT parece "digitar" suas respostas em tempo real? Isso é streaming em ação. Como assistir a um calígrafo habilidoso trabalhando - vendo os caracteres aparecerem traço por traço em vez de materializarem instantaneamente - o streaming torna a interação mais natural e fornece feedback imediato.

Implementando streaming com LangChain

from langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
    streaming=True
)

# Stream the response
for chunk in llm.stream("Write a short story about a robot learning to code"):
    print(chunk.content, end="", flush=True)

Por que o streaming é incrível:

Mostra o conteúdo enquanto está sendo criado - nada de espera constrangedora!
Faz os usuários sentirem que algo está realmente acontecendo
Parece mais rápido, mesmo quando tecnicamente não é
Permite que os usuários comecem a ler enquanto a IA ainda está "pensando"

💡 Dica de Experiência do Usuário: O streaming realmente brilha quando você está lidando com respostas mais longas, como explicações de código, escrita criativa ou tutoriais detalhados. Seus usuários vão adorar ver o progresso em vez de encarar uma tela em branco!

🎯 Verificação Pedagógica: Benefícios da Abstração de Frameworks

Pausa e Reflexão: Você acabou de experimentar o poder das abstrações de frameworks de IA. Compare o que aprendeu com chamadas de API diretas de lições anteriores.

Autoavaliação Rápida:

Você consegue explicar como o LangChain simplifica o gerenciamento de conversas em comparação com o rastreamento manual de mensagens?
Qual é a diferença entre os métodos invoke() e stream(), e quando você usaria cada um?
Como o sistema de tipos de mensagens do framework melhora a organização do código?

Conexão com o Mundo Real: Os padrões de abstração que você aprendeu (tipos de mensagens, interfaces de streaming, memória de conversação) são usados em todas as principais aplicações de IA - desde a interface do ChatGPT até a assistência de código do GitHub Copilot. Você está dominando os mesmos padrões arquitetônicos usados por equipes profissionais de desenvolvimento de IA.

Pergunta Desafiadora: Como você projetaria uma abstração de framework para lidar com diferentes provedores de modelos de IA (OpenAI, Anthropic, Google) com uma única interface? Considere os benefícios e as desvantagens.

Templates de prompts

Templates de prompts funcionam como as estruturas retóricas usadas na oratória clássica - pense em como Cícero adaptaria seus padrões de discurso para diferentes públicos enquanto mantinha o mesmo framework persuasivo. Eles permitem criar prompts reutilizáveis onde você pode trocar diferentes partes de informação sem reescrever tudo do zero. Depois de configurar o template, basta preencher as variáveis com os valores necessários.

Criando prompts reutilizáveis

from langchain_core.prompts import ChatPromptTemplate

# Define a template for code explanations
template = ChatPromptTemplate.from_messages([
    ("system", "You are an expert programming instructor. Explain concepts clearly with examples."),
    ("human", "Explain {concept} in {language} with a practical example for {skill_level} developers")
])

# Use the template with different values
questions = [
    {"concept": "functions", "language": "JavaScript", "skill_level": "beginner"},
    {"concept": "classes", "language": "Python", "skill_level": "intermediate"},
    {"concept": "async/await", "language": "JavaScript", "skill_level": "advanced"}
]

for question in questions:
    prompt = template.format_messages(**question)
    response = llm.invoke(prompt)
    print(f"Topic: {question['concept']}\n{response.content}\n---\n")

Por que você vai adorar usar templates:

Mantém seus prompts consistentes em todo o aplicativo
Nada de concatenação de strings bagunçada - apenas variáveis limpas e simples
Sua IA se comporta de forma previsível porque a estrutura permanece a mesma
Atualizações são fáceis - altere o template uma vez e estará corrigido em todos os lugares

Saída estruturada

Já ficou frustrado tentando analisar respostas de IA que chegam como texto não estruturado? Saída estruturada é como ensinar sua IA a seguir a abordagem sistemática que Lineu usou para classificação biológica - organizada, previsível e fácil de trabalhar. Você pode solicitar JSON, estruturas de dados específicas ou qualquer formato necessário.

Definindo esquemas de saída

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import JsonOutputParser
from pydantic import BaseModel, Field

class CodeReview(BaseModel):
    score: int = Field(description="Code quality score from 1-10")
    strengths: list[str] = Field(description="List of code strengths")
    improvements: list[str] = Field(description="List of suggested improvements")
    overall_feedback: str = Field(description="Summary feedback")

# Set up the parser
parser = JsonOutputParser(pydantic_object=CodeReview)

# Create prompt with format instructions
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a code reviewer. {format_instructions}"),
    ("human", "Review this code: {code}")
])

# Format the prompt with instructions
chain = prompt | llm | parser

# Get structured response
code_sample = """
def calculate_average(numbers):
    return sum(numbers) / len(numbers)
"""

result = chain.invoke({
    "code": code_sample,
    "format_instructions": parser.get_format_instructions()
})

print(f"Score: {result['score']}")
print(f"Strengths: {', '.join(result['strengths'])}")

Por que saída estruturada é um divisor de águas:

Nada de adivinhar o formato que você receberá - é consistente todas as vezes
Conecta-se diretamente aos seus bancos de dados e APIs sem trabalho extra
Detecta respostas estranhas da IA antes que elas quebrem seu aplicativo
Torna seu código mais limpo porque você sabe exatamente com o que está lidando

Chamadas de ferramentas

Agora chegamos a um dos recursos mais poderosos: ferramentas. É assim que você dá à sua IA capacidades práticas além da conversa. Como as guildas medievais desenvolveram ferramentas especializadas para ofícios específicos, você pode equipar sua IA com instrumentos focados. Você descreve quais ferramentas estão disponíveis e, quando alguém solicita algo que corresponda, sua IA pode agir.

Usando Python

Vamos adicionar algumas ferramentas assim:

from typing_extensions import Annotated, TypedDict

class add(TypedDict):
    """Add two integers."""

    # Annotations must have the type and can optionally include a default value and description (in that order).
    a: Annotated[int, ..., "First integer"]
    b: Annotated[int, ..., "Second integer"]

tools = [add]

functions = {
    "add": lambda a, b: a + b
}

Então, o que está acontecendo aqui? Estamos criando um modelo para uma ferramenta chamada add. Ao herdar de TypedDict e usar esses tipos elegantes Annotated para a e b, estamos dando ao LLM uma imagem clara do que essa ferramenta faz e do que ela precisa. O dicionário functions é como nossa caixa de ferramentas - ele informa ao código exatamente o que fazer quando a IA decide usar uma ferramenta específica.

Vamos ver como chamamos o LLM com essa ferramenta a seguir:

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

llm_with_tools = llm.bind_tools(tools)

Aqui chamamos bind_tools com nosso array tools e, assim, o LLM llm_with_tools agora tem conhecimento dessa ferramenta.

Para usar esse novo LLM, podemos digitar o seguinte código:

query = "What is 3 + 12?"

res = llm_with_tools.invoke(query)
if(res.tool_calls):
    for tool in res.tool_calls:
        print("TOOL CALL: ", functions[tool["name"]](../../../10-ai-framework-project/**tool["args"]))
print("CONTENT: ",res.content)

Agora que chamamos invoke nesse novo LLM, que tem ferramentas, talvez a propriedade tool_calls seja preenchida. Se for, qualquer ferramenta identificada terá uma propriedade name e args que identifica qual ferramenta deve ser chamada e com quais argumentos. O código completo é assim:

from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
import os
from typing_extensions import Annotated, TypedDict

class add(TypedDict):
    """Add two integers."""

    # Annotations must have the type and can optionally include a default value and description (in that order).
    a: Annotated[int, ..., "First integer"]
    b: Annotated[int, ..., "Second integer"]

tools = [add]

functions = {
    "add": lambda a, b: a + b
}

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

llm_with_tools = llm.bind_tools(tools)

query = "What is 3 + 12?"

res = llm_with_tools.invoke(query)
if(res.tool_calls):
    for tool in res.tool_calls:
        print("TOOL CALL: ", functions[tool["name"]](../../../10-ai-framework-project/**tool["args"]))
print("CONTENT: ",res.content)

Ao executar este código, você deve ver uma saída semelhante a:

TOOL CALL:  15
CONTENT:

A IA examinou "Qual é 3 + 12" e reconheceu isso como uma tarefa para a ferramenta add. Como um bibliotecário habilidoso sabe qual referência consultar com base no tipo de pergunta feita, ela fez essa determinação a partir do nome, descrição e especificações de campo da ferramenta. O resultado de 15 vem do nosso dicionário functions executando a ferramenta:

print("TOOL CALL: ", functions[tool["name"]](../../../10-ai-framework-project/**tool["args"]))

Uma ferramenta mais interessante que chama uma API web

Adicionar números demonstra o conceito, mas ferramentas reais geralmente realizam operações mais complexas, como chamar APIs da web. Vamos expandir nosso exemplo para que a IA busque conteúdo da internet - semelhante a como operadores de telégrafo conectavam locais distantes:

class joke(TypedDict):
    """Tell a joke."""

    # Annotations must have the type and can optionally include a default value and description (in that order).
    category: Annotated[str, ..., "The joke category"]

def get_joke(category: str) -> str:
    response = requests.get(f"https://api.chucknorris.io/jokes/random?category={category}", headers={"Accept": "application/json"})
    if response.status_code == 200:
        return response.json().get("value", f"Here's a {category} joke!")
    return f"Here's a {category} joke!"

functions = {
    "add": lambda a, b: a + b,
    "joke": lambda category: get_joke(category)
}

query = "Tell me a joke about animals"

# the rest of the code is the same

Agora, se você executar este código, receberá uma resposta dizendo algo como:

TOOL CALL:  Chuck Norris once rode a nine foot grizzly bear through an automatic car wash, instead of taking a shower.
CONTENT:

flowchart TD
    A[User Query: "Tell me a joke about animals"] --> B[LangChain Analysis]
    B --> C{Tool Available?}
    C -->|Yes| D[Select joke tool]
    C -->|No| E[Generate direct response]
    
    D --> F[Extract Parameters]
    F --> G[Call joke(category="animals")]
    G --> H[API Request to chucknorris.io]
    H --> I[Return joke content]
    I --> J[Display to user]
    
    E --> K[AI-generated response]
    K --> J
    
    subgraph "Tool Definition Layer"
        L[TypedDict Schema]
        M[Function Implementation]
        N[Parameter Validation]
    end
    
    D --> L
    F --> N
    G --> M

Aqui está o código completo:

from langchain_openai import ChatOpenAI
import requests
import os
from typing_extensions import Annotated, TypedDict

class add(TypedDict):
    """Add two integers."""

    # Annotations must have the type and can optionally include a default value and description (in that order).
    a: Annotated[int, ..., "First integer"]
    b: Annotated[int, ..., "Second integer"]

class joke(TypedDict):
    """Tell a joke."""

    # Annotations must have the type and can optionally include a default value and description (in that order).
    category: Annotated[str, ..., "The joke category"]

tools = [add, joke]

def get_joke(category: str) -> str:
    response = requests.get(f"https://api.chucknorris.io/jokes/random?category={category}", headers={"Accept": "application/json"})
    if response.status_code == 200:
        return response.json().get("value", f"Here's a {category} joke!")
    return f"Here's a {category} joke!"

functions = {
    "add": lambda a, b: a + b,
    "joke": lambda category: get_joke(category)
}

llm = ChatOpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="openai/gpt-4o-mini",
)

llm_with_tools = llm.bind_tools(tools)

query = "Tell me a joke about animals"

res = llm_with_tools.invoke(query)
if(res.tool_calls):
    for tool in res.tool_calls:
        # print("TOOL CALL: ", tool)
        print("TOOL CALL: ", functions[tool["name"]](../../../10-ai-framework-project/**tool["args"]))
print("CONTENT: ",res.content)

Embeddings e processamento de documentos

Embeddings representam uma das soluções mais elegantes na IA moderna. Imagine se você pudesse pegar qualquer texto e convertê-lo em coordenadas numéricas que capturam seu significado. É exatamente isso que os embeddings fazem - transformam texto em pontos em um espaço multidimensional onde conceitos semelhantes se agrupam. É como ter um sistema de coordenadas para ideias, semelhante a como Mendeleev organizou a tabela periódica com base nas propriedades atômicas.

Criando e usando embeddings

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter

# Initialize embeddings
embeddings = OpenAIEmbeddings(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.github.ai/inference",
    model="text-embedding-3-small"
)

# Load and split documents
loader = TextLoader("documentation.txt")
documents = loader.load()

text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# Create vector store
vectorstore = FAISS.from_documents(texts, embeddings)

# Perform similarity search
query = "How do I handle user authentication?"
similar_docs = vectorstore.similarity_search(query, k=3)

for doc in similar_docs:
    print(f"Relevant content: {doc.page_content[:200]}...")

Carregadores de documentos para vários formatos

from langchain_community.document_loaders import (
    PyPDFLoader,
    CSVLoader,
    JSONLoader,
    WebBaseLoader
)

# Load different document types
pdf_loader = PyPDFLoader("manual.pdf")
csv_loader = CSVLoader("data.csv")
json_loader = JSONLoader("config.json")
web_loader = WebBaseLoader("https://example.com/docs")

# Process all documents
all_documents = []
for loader in [pdf_loader, csv_loader, json_loader, web_loader]:
    docs = loader.load()
    all_documents.extend(docs)

O que você pode fazer com embeddings:

Construir buscas que realmente entendem o que você quer dizer, não apenas correspondência de palavras-chave
Criar IA que pode responder perguntas sobre seus documentos
Fazer sistemas de recomendação que sugerem conteúdo verdadeiramente relevante
Organizar automaticamente e categorizar seu conteúdo

flowchart LR
    A[Documents] --> B[Text Splitter]
    B --> C[Create Embeddings]
    C --> D[Vector Store]
    
    E[User Query] --> F[Query Embedding]
    F --> G[Similarity Search]
    G --> D
    D --> H[Relevant Documents]
    H --> I[AI Response]
    
    subgraph "Vector Space"
        J[Document A: [0.1, 0.8, 0.3...]]
        K[Document B: [0.2, 0.7, 0.4...]]
        L[Query: [0.15, 0.75, 0.35...]]
    end
    
    C --> J
    C --> K
    F --> L
    G --> J
    G --> K

Construindo uma aplicação completa de IA

Agora vamos integrar tudo o que você aprendeu em uma aplicação abrangente - um assistente de codificação que pode responder perguntas, usar ferramentas e manter memória de conversação. Assim como a prensa de impressão combinou tecnologias existentes (tipo móvel, tinta, papel e pressão) em algo transformador, vamos combinar nossos componentes de IA em algo prático e útil.

Exemplo de aplicação completa

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
from langchain_community.vectorstores import FAISS
from typing_extensions import Annotated, TypedDict
import os
import requests

class CodingAssistant:
    def __init__(self):
        self.llm = ChatOpenAI(
            api_key=os.environ["GITHUB_TOKEN"],
            base_url="https://models.github.ai/inference",
            model="openai/gpt-4o-mini"
        )
        
        self.conversation_history = [
            SystemMessage(content="""You are an expert coding assistant. 
            Help users learn programming concepts, debug code, and write better software.
            Use tools when needed and maintain a helpful, encouraging tone.""")
        ]
        
        # Define tools
        self.setup_tools()
    
    def setup_tools(self):
        class web_search(TypedDict):
            """Search for programming documentation or examples."""
            query: Annotated[str, "Search query for programming help"]
        
        class code_formatter(TypedDict):
            """Format and validate code snippets."""
            code: Annotated[str, "Code to format"]
            language: Annotated[str, "Programming language"]
        
        self.tools = [web_search, code_formatter]
        self.llm_with_tools = self.llm.bind_tools(self.tools)
    
    def chat(self, user_input: str):
        # Add user message to conversation
        self.conversation_history.append(HumanMessage(content=user_input))
        
        # Get AI response
        response = self.llm_with_tools.invoke(self.conversation_history)
        
        # Handle tool calls if any
        if response.tool_calls:
            for tool_call in response.tool_calls:
                tool_result = self.execute_tool(tool_call)
                print(f"🔧 Tool used: {tool_call['name']}")
                print(f"📊 Result: {tool_result}")
        
        # Add AI response to conversation
        self.conversation_history.append(response)
        
        return response.content
    
    def execute_tool(self, tool_call):
        tool_name = tool_call['name']
        args = tool_call['args']
        
        if tool_name == 'web_search':
            return f"Found documentation for: {args['query']}"
        elif tool_name == 'code_formatter':
            return f"Formatted {args['language']} code: {args['code'][:50]}..."
        
        return "Tool execution completed"

# Usage example
assistant = CodingAssistant()

print("🤖 Coding Assistant Ready! Type 'quit' to exit.\n")

while True:
    user_input = input("You: ")
    if user_input.lower() == 'quit':
        break
    
    response = assistant.chat(user_input)
    print(f"🤖 Assistant: {response}\n")

Arquitetura da aplicação:

graph TD
    A[User Input] --> B[Coding Assistant]
    B --> C[Conversation Memory]
    B --> D[Tool Detection]
    B --> E[LLM Processing]
    
    D --> F[Web Search Tool]
    D --> G[Code Formatter Tool]
    
    E --> H[Response Generation]
    F --> H
    G --> H
    
    H --> I[User Interface]
    H --> C

Principais recursos que implementamos:

Lembra toda a sua conversa para continuidade de contexto
Realiza ações através de chamadas de ferramentas, não apenas conversa
Segue padrões de interação previsíveis
Gerencia tratamento de erros e fluxos de trabalho complexos automaticamente

🎯 Verificação Pedagógica: Arquitetura de IA para Produção

Compreensão da Arquitetura: Você construiu uma aplicação completa de IA que combina gerenciamento de conversação, chamadas de ferramentas e fluxos de trabalho estruturados. Isso representa o desenvolvimento de aplicações de IA em nível de produção.

Conceitos-chave dominados:

Arquitetura baseada em classes: Estrutura organizada e sustentável para aplicações de IA
Integração de ferramentas: Funcionalidade personalizada além da conversa
Gerenciamento de memória: Contexto persistente de conversação
Tratamento de erros: Comportamento robusto da aplicação

Conexão com a indústria: Os padrões de arquitetura que você implementou (classes de conversação, sistemas de ferramentas, gerenciamento de memória) são os mesmos usados em aplicações de IA empresariais como o assistente de IA do Slack, GitHub Copilot e Microsoft Copilot. Você está construindo com pensamento arquitetônico de nível profissional.

Pergunta de Reflexão: Como você estenderia esta aplicação para lidar com múltiplos usuários, armazenamento persistente ou integração com bancos de dados externos? Considere os desafios de escalabilidade e gerenciamento de estado.

Tarefa: Construa seu próprio assistente de estudo com IA

Objetivo: Crie uma aplicação de IA que ajude estudantes a aprender conceitos de programação fornecendo explicações, exemplos de código e questionários interativos.

Requisitos

Recursos principais (obrigatórios):

Interface de conversação: Implemente um sistema de chat que mantenha o contexto em várias perguntas
Ferramentas educacionais: Crie pelo menos duas ferramentas que ajudem no aprendizado:
- Ferramenta de explicação de código
- Gerador de questionários sobre conceitos
Aprendizado personalizado: Use mensagens do sistema para adaptar respostas a diferentes níveis de habilidade
Formatação de respostas: Implemente saída estruturada para perguntas de questionário

Etapas de implementação

Etapa 1: Configure seu ambiente

pip install langchain langchain-openai

Etapa 2: Funcionalidade básica de chat

Crie uma classe StudyAssistant
Implemente memória de conversação
Adicione configuração de personalidade para suporte educacional

Etapa 3: Adicione ferramentas educacionais

Explicador de Código: Divide o código em partes compreensíveis
Gerador de Questionários: Cria perguntas sobre conceitos de programação
Rastreador de Progresso: Acompanha os tópicos abordados

Etapa 4: Recursos avançados (opcional)

Implemente respostas em streaming para melhor experiência do usuário
Adicione carregamento de documentos para incorporar materiais de curso
Crie embeddings para recuperação de conteúdo baseada em similaridade

Critérios de avaliação

Recurso	Excelente (4)	Bom (3)	Satisfatório (2)	Precisa melhorar (1)
Fluxo de Conversação	Respostas naturais e com contexto	Boa retenção de contexto	Conversa básica	Sem memória entre trocas
Integração de Ferramentas	Várias ferramentas úteis funcionando perfeitamente	2+ ferramentas implementadas corretamente	1-2 ferramentas básicas	Ferramentas não funcionais
Qualidade do Código	Limpo, bem documentado, com tratamento de erros	Boa estrutura, alguma documentação	Funcionalidade básica funciona	Estrutura ruim, sem tratamento de erros
Valor Educacional	Realmente útil para aprendizado, adaptativo	Bom suporte ao aprendizado	Explicações básicas	Benefício educacional limitado

Estrutura de código de exemplo

class StudyAssistant:
    def __init__(self, skill_level="beginner"):
        # Initialize LLM, tools, and conversation memory
        pass
    
    def explain_code(self, code, language):
        # Tool: Explain how code works
        pass
    
    def generate_quiz(self, topic, difficulty):
        # Tool: Create practice questions
        pass
    
    def chat(self, user_input):
        # Main conversation interface
        pass

# Example usage
assistant = StudyAssistant(skill_level="intermediate")
response = assistant.chat("Explain how Python functions work")

Desafios bônus:

Adicione capacidades de entrada/saída de voz
Implemente uma interface web usando Streamlit ou Flask
Crie uma base de conhecimento a partir de materiais de curso usando embeddings
Adicione rastreamento de progresso e caminhos de aprendizado personalizados

📈 Linha do tempo de domínio do desenvolvimento de frameworks de IA

timeline
    title Production AI Framework Development Journey
    
    section Framework Foundations
        Understanding Abstractions
            : Master framework vs API decisions
            : Learn LangChain core concepts
            : Implement message type systems
        
        Basic Integration
            : Connect to AI providers
            : Handle authentication
            : Manage configuration
    
    section Conversation Systems
        Memory Management
            : Build conversation history
            : Implement context tracking
            : Handle session persistence
        
        Advanced Interactions
            : Master streaming responses
            : Create prompt templates
            : Implement structured output
    
    section Tool Integration
        Custom Tool Development
            : Design tool schemas
            : Implement function calling
            : Handle external APIs
        
        Workflow Automation
            : Chain multiple tools
            : Create decision trees
            : Build agent behaviors
    
    section Production Applications
        Complete System Architecture
            : Combine all framework features
            : Implement error boundaries
            : Create maintainable code
        
        Enterprise Readiness
            : Handle scalability concerns
            : Implement monitoring
            : Build deployment strategies

🎓 Marco de Graduação: Você dominou com sucesso o desenvolvimento de frameworks de IA usando as mesmas ferramentas e padrões que alimentam aplicações modernas de IA. Essas habilidades representam o estado da arte no desenvolvimento de aplicações de IA e preparam você para construir sistemas inteligentes de nível empresarial.

🔄 Capacidades de próximo nível:

Pronto para explorar arquiteturas avançadas de IA (agentes, sistemas multiagentes)
Preparado para construir sistemas RAG com bancos de dados vetoriais
Equipado para criar aplicações de IA multimodais
Base estabelecida para escalabilidade e otimização de aplicações de IA

Resumo

🎉 Você agora dominou os fundamentos do desenvolvimento de frameworks de IA e aprendeu como construir aplicações sofisticadas de IA usando LangChain. Como completar um aprendizado abrangente, você adquiriu um conjunto substancial de habilidades. Vamos revisar o que você conquistou.

O que você aprendeu

Conceitos principais do framework:

Benefícios do framework: Entender quando escolher frameworks em vez de chamadas diretas de API
Fundamentos do LangChain: Configurar e conectar modelos de IA
Tipos de mensagens: Usar SystemMessage, HumanMessage e AIMessage para conversas estruturadas

Recursos avançados:

Chamadas de ferramentas: Criar e integrar ferramentas personalizadas para capacidades aprimoradas de IA
Memória de conversação: Manter o contexto em várias interações
Respostas em streaming: Implementar entrega de respostas em tempo real
Templates de prompts: Construir prompts reutilizáveis e dinâmicos
Saída estruturada: Garantir respostas consistentes e analisáveis da IA
Embeddings: Criar busca semântica e capacidades de processamento de documentos

Aplicações práticas:

Construção de aplicativos completos: Combinar múltiplos recursos em aplicações prontas para produção
Tratamento de erros: Implementar gerenciamento robusto de erros e validação
Integração de ferramentas: Criar ferramentas personalizadas que ampliam as capacidades da IA

Principais aprendizados

🎯 Lembre-se: Frameworks de IA como LangChain são basicamente seus melhores amigos para esconder complexidade e oferecer recursos avançados. Eles são perfeitos quando você precisa de memória de conversação, chamadas de ferramentas ou quer trabalhar com vários modelos de IA sem perder a sanidade.

Framework de decisão para integração de IA:

flowchart TD
    A[AI Integration Need] --> B{Simple single query?}
    B -->|Yes| C[Direct API calls]
    B -->|No| D{Need conversation memory?}
    D -->|No| E[SDK Integration]
    D -->|Yes| F{Need tools or complex features?}
    F -->|No| G[Framework with basic setup]
    F -->|Yes| H[Full framework implementation]
    
    C --> I[HTTP requests, minimal dependencies]
    E --> J[Provider SDK, model-specific]
    G --> K[LangChain basic chat]
    H --> L[LangChain with tools, memory, agents]

Para onde ir a partir daqui?

Comece a construir agora mesmo:

Pegue esses conceitos e crie algo que te empolgue!
Experimente diferentes modelos de IA através do LangChain - é como ter um playground de modelos de IA
Crie ferramentas que resolvam problemas reais que você enfrenta no trabalho ou em projetos

Pronto para o próximo nível?

Agentes de IA: Construa sistemas de IA que possam planejar e executar tarefas complexas por conta própria
RAG (Geração Aumentada por Recuperação): Combine IA com suas próprias bases de conhecimento para aplicações superpotentes
IA Multimodal: Trabalhe com texto, imagens e áudio juntos - as possibilidades são infinitas!
Implantação em Produção: Aprenda como escalar suas aplicações de IA e monitorá-las no mundo real

Junte-se à comunidade:

A comunidade LangChain é fantástica para se manter atualizado e aprender as melhores práticas
Modelos do GitHub oferecem acesso a capacidades de IA de ponta - perfeito para experimentação
Continue praticando com diferentes casos de uso - cada projeto ensinará algo novo

Agora você tem o conhecimento para construir aplicações inteligentes e conversacionais que podem ajudar as pessoas a resolver problemas reais. Como os artesãos do Renascimento que combinavam visão artística com habilidade técnica, você agora pode unir as capacidades da IA com aplicações práticas. A pergunta é: o que você vai criar? 🚀

Desafio do Agente do GitHub Copilot 🚀

Use o modo Agente para completar o seguinte desafio:

Descrição: Construa um assistente avançado de revisão de código com IA que combine múltiplos recursos do LangChain, incluindo chamadas de ferramentas, saída estruturada e memória de conversação para fornecer feedback abrangente sobre submissões de código.

Prompt: Crie uma classe CodeReviewAssistant que implemente:

Uma ferramenta para analisar a complexidade do código e sugerir melhorias
Uma ferramenta para verificar o código em relação às melhores práticas
Saída estruturada usando modelos Pydantic para formato consistente de revisão
Memória de conversação para acompanhar sessões de revisão
Uma interface principal de chat que possa lidar com submissões de código e fornecer feedback detalhado e acionável

O assistente deve ser capaz de revisar código em várias linguagens de programação, manter o contexto em várias submissões de código em uma sessão e fornecer tanto pontuações resumidas quanto sugestões detalhadas de melhorias.

Saiba mais sobre o modo agente aqui.

Aviso Legal:
Este documento foi traduzido usando o serviço de tradução por IA Co-op Translator. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.