Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

2
respostas

[Projeto] Usando O llama 3.1-8b

o código:

from openai import OpenAI
from dotenv import load_dotenv
import os
import json

load_dotenv()

client = OpenAI(
    base_url=os.getenv("BASE_URL"),
    api_key=os.getenv("API_KEY"),
    timeout=300
)

modelo = os.getenv("MODEL_ALTERNATIVO")


def carregar(nome_arquivo):
    try:
        with open(nome_arquivo, "r", encoding="utf-8") as arquivo:
            dados = json.load(arquivo)
            return dados["transacoes"]

    except FileNotFoundError:
        raise Exception(f"Arquivo '{nome_arquivo}' não encontrado.")

    except json.JSONDecodeError as e:
        raise Exception(f"JSON inválido: {e}")


def salvar(data, arquivo_json):
    try:
        with open(arquivo_json, "w", encoding="utf-8") as arquivo:
            json.dump(
                data,
                arquivo,
                indent=4,
                ensure_ascii=False
            )

    except Exception as e:
        raise Exception(f"Erro ao salvar o arquivo {arquivo_json}: {e}")


def analisar_transacao(lista_transacoes):

    print("1. Executando a análise das transações")

    prompt_sistema = """
Você é um analista de fraude.

Analise a transação abaixo.

Retorne apenas:

{
"id":"",
"status":"Aprovado" ou "Possível Fraude"
}
"""

    lista_mensagens = [
        {
            "role": "system",
            "content": prompt_sistema
        },
        {
            "role": "user",
            "content": json.dumps(
                lista_transacoes,
                ensure_ascii=False,
                indent=2
            )
        }
    ]

    resposta = client.chat.completions.create(
        messages=lista_mensagens,
        model=modelo,
        temperature=0
    )

    conteudo = (
        resposta.choices[0]
        .message.content
        .replace("```json", "")
        .replace("```", "")
        .strip()
    )

    print("\nConteúdo:")
    print(conteudo)

    json_resultado = json.loads(conteudo)

    print("\nJSON carregado com sucesso!")

    return json_resultado


def gerar_parecer(transacao):

    print("2. Gerando parecer")

    prompt = f"""
Para a seguinte transação:

{json.dumps(transacao, ensure_ascii=False, indent=2)}

Caso o status seja "Possível Fraude",
gere um parecer técnico justificando.

Caso contrário escreva:

Não Aplicável
"""

    resposta = client.chat.completions.create(
        model=modelo,
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ]
    )

    print("Finalizou a geração do parecer")

    return resposta.choices[0].message.content


def gerar_recomendacao(parecer):

    print("3. Gerando recomendação")

    prompt = f"""
Considere o seguinte parecer:

{parecer}

Forneça uma recomendação técnica.

Escolha entre:

- Notificar Cliente
- Acionar setor Anti-Fraude
- Realizar Verificação Manual

Inclua também uma classificação do tipo de fraude.
"""

    resposta = client.chat.completions.create(
        model=modelo,
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ]
    )

    print("Finalizou a geração da recomendação")

    return resposta.choices[0].message.content


# ==========================
# Programa Principal
# ==========================

lista_de_transacoes = carregar("transacoes.json")

transacoes_analisadas = analisar_transacao(lista_de_transacoes)

for uma_transacao in transacoes_analisadas["transacoes"]:

    if uma_transacao["status"] == "Possível Fraude":

        um_parecer = gerar_parecer(uma_transacao)

        print("\nParecer:")
        print(um_parecer)

        recomendacao = gerar_recomendacao(um_parecer)

        id_transacao = uma_transacao["id"]

        produto_transacao = (
            uma_transacao["nome_produto"]
            .replace(" ", "_")
            .replace("/", "_")
        )

        status_transacao = (
            uma_transacao["status"]
            .replace(" ", "_")
        )

        salvar(
            {
                "transacao": uma_transacao,
                "parecer": um_parecer,
                "recomendacao": recomendacao
            },
            f"transacao-{id_transacao}-{produto_transacao}-{status_transacao}.json"
        )

print("\nProcessamento finalizado!")

O resultado no log ficou assim:
Resposta no coment

2 respostas
1. Executando a análise das transações

Conteúdo:
Aqui está a análise das transações:

[
  {
    "id": 1,
    "status": "Possível Fraude"
  },
  {
    "id": 2,
    "status": "Aprovado"
  },
  {
    "id": 3,
    "status": "Aprovado"
  },
  {
    "id": 4,
    "status": "Possível Fraude"
  },
  {
    "id": 5,
    "status": "Aprovado"
  },
  {
    "id": 6,
    "status": "Possível Fraude"
  },
  {
    "id": 7,
    "status": "Aprovado"
  },
  {
    "id": 8,
    "status": "Possível Fraude"
  },
  {
    "id": 9,
    "status": "Possível Fraude"
  },
  {
    "id": 10,
    "status": "Aprovado"
  }
]

Explicação:

- Transações com valor muito alto (R$ 18.900,00, R$ 12.999,00, R$ 185.000,00 e R$ 22.500,00) são consideradas possíveis fraude.
- Transações realizadas em locais fora do Brasil (Dubai e Miami) também são consideradas possíveis fraude.
- As demais transações foram consideradas aprovadas.

Fala, Paulo! Tudo bom?

Agradeço por trazer sua solução para o fórum!

Curti demais como trabalhou a integração com API para análise de transações com Python, entendeu perfeitamente a importância da estrutura de prompts para guiar a resposta do modelo e utilizou bem o tratamento de erros para garantir robustez no fluxo.

Algo bem legal para complementar é ajustar o retorno da função analisar_transacao para lidar com múltiplas transações de forma mais clara. Dessa maneira:

def analisar_transacao(lista_transacoes):
    print("1. Executando a análise das transações")
    prompt_sistema = """
    Você é um analista de fraude.
    Analise as transações abaixo.
    Retorne apenas:
    {
        "transacoes": [
            {"id":"", "status":"Aprovado" ou "Possível Fraude"}
        ]
    }
    """
    mensagens = [
        {"role": "system", "content": prompt_sistema},
        {"role": "user", "content": json.dumps(lista_transacoes, ensure_ascii=False, indent=2)}
    ]

    resposta = client.chat.completions.create(
        messages=mensagens,
        model=modelo,
        temperature=0
    )

    conteudo = resposta.choices[0].message.content.strip()
    print("\nConteúdo:")
    print(conteudo)

    json_resultado = json.loads(conteudo)
    print("\nJSON carregado com sucesso!")
    return json_resultado

Isso faz com que o modelo retorne uma lista de transações já estruturada, facilitando o loop posterior.

Se quiser aprofundar ainda mais, algumas boas práticas são:

  • Logs estruturados: salvar os resultados em arquivos de log para auditoria.
  • Validação de schema: garantir que o JSON retornado siga o formato esperado antes de processar.
  • Escalabilidade: permitir que o programa leia transações de diferentes fontes (CSV, banco de dados, API).

Continue postando as suas soluções! Além de ganhar pontos de XP na plataforma, você pode ajudar outros estudantes no fórum.

Ah, uma pergunta: você prefere manter o fluxo todo em arquivos locais ou já pensa em evoluir para integrar diretamente com uma base de dados transacional?

Abraço e bons estudos!

Alura Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!