JEV+RUST vs Python+DeepSeek: detectando fraudes no Pix em tempo real!

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: JEV+RUST vs Python+Deepseek: Detectando fraudes no Pix em tempo real! · Canal: Sandeco · 14:45 · Assistir no YouTube

Tópicos: Avaliação e benchmarks de IA, Cibersegurança e segurança de software, Engenharia de software com IA, Modelos de IA, Open source e ecossistemas de software

Resumo

O vídeo demonstra um detector de fraudes no Pix que compara Jev com Rust a uma implementação em Python com DeepSeek, usando as mesmas mensagens e dados de transações. Na demonstração, Rust com Jev processa os dados mais rapidamente e consome menos memória, enquanto Python com DeepSeek detecta uma fraude a mais no conjunto de teste. O apresentador também mostra como criou a aplicação com Reversa New e Reversa Forward, usando Claude Code. Ao final, destaca que a linguagem de programação pode limitar a velocidade de um modelo.

Pontos-chave

A demonstração compara Rust com Jev e Python com DeepSeek no processamento de mensagens suspeitas de fraude no Pix.
O conjunto mencionado inclui 10 milhões de transações, 1 milhão de contas e mais de 1.000 mensagens.
O uso de memória apresentado foi de 128 MB para Rust e 1,6 GB para Python.
O processamento foi linear, sem uso de threads paralelas.
O tempo total informado foi de 307 segundos para Jev com Rust e 1.047 segundos para Python com DeepSeek.
Rust com Jev detectou 74 das 75 fraudes injetadas; Python com DeepSeek detectou as 75.
A aplicação exibe relações entre contas, transações e contas intermediárias associadas ao fluxo do dinheiro.
Reversa New foi usado para elaborar as especificações, e Reversa Forward para implementar a aplicação.

Capítulos

Início	Capítulo	Resumo
00:01	Demonstração e comparação dos detectores	O apresentador introduz a comparação entre Jev com Rust e DeepSeek com Python e demonstra a interface de detecção.
04:43	Desempenho e resultados da detecção	A demonstração compara os tempos de processamento, o uso de memória e a quantidade de fraudes identificadas.
08:23	Criação da aplicação com Reversa	O apresentador explica a configuração do Reversa New e os requisitos descritos para gerar a aplicação.
12:09	Implementação e execução da aplicação	Depois de gerar as especificações e o código com Reversa Forward, o apresentador inicia e testa o servidor local.

Citações

Em Rust, o uso de memória foi de 128 MB para carregar os dados; em Python, foi de 1,6 GB. — 01:36

Rust com Jev foi três vezes mais rápido que Python com DeepSeek. — 05:46

Rust com Jev detectou 74 fraudes; Python conseguiu detectar as 75. — 07:21

A própria linguagem de programação pode limitar a velocidade do modelo. — 14:45

Conceitos e entidades

Jev (modelo): Modelo usado na aplicação em Rust para classificar mensagens e identificar possíveis fraudes.
DeepSeek (modelo): Modelo usado na implementação em Python, comparada à versão com Jev e Rust.
Rust (ferramenta): Linguagem de programação usada na implementação que combina com Jev.
Python (ferramenta): Linguagem de programação usada na implementação com DeepSeek.
Reversa (ferramenta): Framework apresentado para orientar a criação de aplicações.
Reversa New (ferramenta): Modo do Reversa usado para criar uma aplicação e suas especificações a partir do zero.
Reversa Forward (ferramenta): Etapa do Reversa acionada no vídeo para realizar a implementação da aplicação.
Claude Code (ferramenta): Ferramenta usada no VS Code durante a instalação do Reversa e a execução do servidor.
Sandeco (pessoa): Apresentador do vídeo e criador do canal Sandeco.
GGUF (conceito): Formato mencionado pelo apresentador na comparação final sobre velocidade.

Tradução completa (pt-BR)

00:01 Hoje vou construir com vocês usando o Reversa, um aplicativo baseado no modelo Jev, combinado com a linguagem supersônica Rust, para a tarefa de detectar fraudes no Pix em tempo real. Nosso banco de dados tem 10 milhões de transações, 1 milhão de contas e mais de 1.000 mensagens de WhatsApp. E vamos comparar o desempenho desse aplicativo com o de um aplicativo também construído com Python e DeepSeek. É inteligência artificial

00:32 em modo supersônico. Olá, como vão vocês? Eu sou Sandeco. Sou professor e pesquisador no Instituto Federal de Goiás e na Universidade Federal de Goiás. E falo sobre inteligência artificial aqui no YouTube há quase 10 anos. Se vocês gostam de informações sobre inteligência artificial sem complicação, mas sem perder a qualidade técnica, espero que considerem se inscrever no meu canal. Ativem as notificações para não

01:06 perder nenhuma novidade e, se quiserem conversar comigo pessoalmente, há um grupo de WhatsApp com o link aqui embaixo, na descrição, do qual vocês podem participar, certo? Beleza, este aqui é o nosso detector de golpes. Este rosa aqui é Rust com Jev. E aqui está Python com DeepSeek, nas cores de Jev e DeepSeek. A primeira coisa importante que vemos aqui, pessoal, é a quantidade de memória usada por cada linguagem de programação. Olhem aqui. Em Rust, o uso de memória ficou em 128 MB para carregar os

01:36 dados na memória. E aqui, em Python, são 1,6 GB. Só por aí já dá para ver o consumo e a otimização da própria linguagem. Aqui em cima, tenho duas opções interessantes: narrado em 4 segundos e normal. Este modo narrado vai mostrar uma mensagem, poderemos vê-la por 4 segundos e, depois, ele passa para a próxima, depois para a próxima e para a seguinte. Mas, quando começarmos a processar, podemos mudar normalmente para o ritmo normal aqui, e o processamento começa a acontecer de forma acelerada. Então vamos começar

02:07 clicando em iniciar no modo narrado, e vocês veem que os dois começam a processar igualmente, e Rust já começa a ficar um pouco mais rápido, estão vendo? Nesse processo. Então, o que vou fazer aqui é o seguinte. Vocês estão vendo as mensagens sendo enviadas, certo? Até agora, não apareceu nenhuma mensagem de golpe. Nossa, apareceu um golpe aqui. E posso descer aqui, olhem, descer aqui e conferir o golpe, olhem. Estão vendo? Se eu clicar aqui, olhem que interessante: ele coloca exatamente este gráfico aqui, porque este gráfico mostra a

02:38 relação entre as contas para conseguir encontrar o golpe. Se eu clicar no golpe aqui, especificamente, vejam, posso ver os detalhes, certo? A classificação que ele definiu ali como boleto falso, certo? A decisão do Jev levou 345 milissegundos e o processamento interno do Rust levou 27 ms, certo? Certo. Vejam como é rápido: a combinação dessas duas linguagens é muito rápida. Daqui a pouco, vou mostrar como essas velocidades se comparam com DeepSeek e Python. Mas aqui embaixo

03:10 ele mostra todas as probabilidades de golpe, certo? Se pede um Pix ou não, se demonstra urgência ou confiança, certo? Certo. Aqui temos o modelo e o custo, certo, em termos de tokens. E aqui embaixo, tenho o custo em dólares da decisão e das mensagens. Do lado direito, é legal que podemos ver, certo? Quando passamos o mouse sobre a entidade aqui em cima, podemos ver a origem, as contas, que são as contas intermediárias, para onde o dinheiro foi enviado, certo? Para chegar ao suspeito aqui embaixo,

03:41 que é a conta de saque final do cara que está roubando você, digamos. E aqui embaixo também estão as contas intermediárias e a conta de saque, certo? Certo. Então, se eu fechar isto, já tenho um golpe aqui, vejam, que foi encontrado; o mesmo golpe aqui. Dá para ver que é o mesmo golpe, vejam, foi encontrado pelo DeepSeek. Entenderam? Então, se eu clicar aqui, vocês veem a diferença. Olhem a diferença. Primeiro, o DeepSeek levou quase 1 segundo, ou seja, três vezes mais lento, certo? E aqui, o rastreamento do Python levou 300 milissegundos, ou seja,

04:12 10 vezes mais lento, entenderam? Não adianta combinar Jev com qualquer linguagem. O legal é combiná-lo com uma linguagem super-rápida, como Rust. E agora, o que vou fazer aqui em cima é mostrar a diferença. Vejam, está bem próximo, certo? Mas, se eu definir como normal, vocês vão começar a notar a diferença monstruosa em comparação com Rust com Jev versus Python. Olhem como acelera, pessoal, como é rápido

04:43 Jev com Rust. E, sempre que aparece um golpe, a tela pisca para nós e tudo mais, e as sequências de golpes detectadas pelo sistema começam a aparecer aqui embaixo. Vou deixar rodar até o fim e acelerar o vídeo para vocês verem como o processamento é diferente entre Rust com Jev e Python com DeepSeek. Vamos lá. Neste ponto, pessoal, Rust terminou o processamento, certo? Todas

05:15 as 1.000 mensagens, certo? Lembrem-se de que esses processos aqui, pessoal, são processamentos lineares. Não abri threads de processamento. Eu poderia ter aberto, digamos, quatro threads, cinco threads, certo? Para fazer esse processamento em paralelo, o que seria muito mais rápido. Mas, como eu queria analisar, digamos, de forma bruta, as duas linguagens e os dois modelos, certo? Deixei no formato linear. Vejam que já processei 1.000 mensagens aqui com Rust e, quando

05:46 paramos, ele estava em 300 e poucas mensagens, certo? Ou seja, Rust com Jev foi três vezes mais rápido do que Python com DeepSeek, certo? Pelo menos isso, certo? E sem usar nenhum processamento paralelo. Vou deixar o DeepSeek terminar aqui para vocês verem e terem uma ideia do tempo total que o processamento com Rust e Python leva, assim como Rust com Jev, certo? Certo. Beleza, o processo

06:18 terminou e agora vamos ver o relatório de precisão, certo? Tenho aqui o tempo total do Jev: 307 segundos, e o tempo total do Python: 1.047 segundos. Olhem a diferença, é enorme, certo, pessoal? Aqui está o tempo, certo, pela mediana. Este P50 é o percentil 50, ou seja, metade das decisões levou 298 milissegundos. No entanto, tenho decisões que levaram mais tempo do que isso, mas, em média, certo

06:48 ? 298 milissegundos para o Jev e 25 milissegundos para o rastreamento do Rust, enquanto a decisão do DeepSeek levou cerca de 1 segundo, mais de 1 segundo, certo? 1.027 milissegundos, entenderam? E o rastreamento do Python levou 243 milissegundos. Vocês veem que aqui há um valor quase três vezes maior, certo? E aqui, na comparação entre Rust e Python,

07:21 o processamento é quase 10 vezes mais rápido, certo? Depois temos a precisão: na verdade, foram inseridos 75 golpes no banco de dados, certo? Rust com Jev conseguiu detectar 74 golpes, um a menos, certo? E Python conseguiu detectar todos os 75. Então, esta é uma informação muito importante, porque há uma pequena queda na precisão aqui em relação ao Jev, certo? Esse foi o único ponto em que

07:53 Python venceu em custo. E aqui tenho, olhem, 0,025 de dólar, e aqui, centavos de dólar, 1/4 do valor. Isso é muito poderoso. Certo? Muito bem. Agora vou mostrar como construí este aplicativo usando o novo agent Reversa chamado Reversa New. Não exatamente novo, certo? O pessoal já está usando bastante por aí, mas esta é a primeira vez que falo sobre o Reversa New aqui

08:23 no canal Sandeco. Ele serve para criar aplicativos do zero usando o framework Reversa. Vamos lá. Já estou aqui em uma pasta dentro do VS Code chamada Pix Golp, certo? com o Claude Code aberto aqui, com a extensão Claude Code para VS Code, certo? Vou fechar isto e agora vou pressionar Ctrl + J e pedir para instalar o Reversa, certo? Com este comando, certo? NPX Reversa install. Bem, vocês já conhecem o Reversa, certo? No Reversa, vocês vêm aqui e escolhem qual harness querem usar. Vou usar este aqui, certo? Vou pedir para ele deixar instalado aqui, olhem.

08:54 Tem até o novo Hermes aqui, certo, para vocês também poderem usar, mas basicamente vou ativá-lo para Claude Code e Codex, certo? Vou colocar o nome Pix Golp aqui, meu nome, Sandeco, depois português como idioma das especificações, ou specs, e vou dizer que quero conversar, certo, para resolver issues diretamente no chat. Depois da instalação, é bom reiniciar a sessão e executar reversa new, -new. O que esse reversa new faz? Ele constrói aplicativos do zero. Vai orientar vocês ao longo do

09:27 construir um aplicativo do zero com você. Então ele vai perguntar isto, certo? Como você quer executar o Reversa New? No modo guiado, ou seja, vamos conversar detalhadamente sobre como será o software, ou no modo expresso. Você quer construí-lo bem rápido. Vou escolher o modo expresso aqui, certo? Porque quero construir este aplicativo muito rápido, especialmente porque este aplicativo é muito simples; a ideia é bem simples. No modo expresso, ele me pediu para dizer o que quero construir. Então escrevi um prompt inteiro

09:59 aqui, pessoal, bem detalhado sobre o que estou procurando. Vou ler rapidamente o que quero, certo? Quero construir uma demonstração com tela dividida para mostrar, ao vivo, a detecção de um golpe no Pix e o rastreamento do caminho do dinheiro até a quadrilha. No lado esquerdo, o Rust roda com o Jev da Type Safety AI, e, no lado direito, o Python roda com o DeepSeek. As mesmas mensagens em português entram nos dois lados ao mesmo tempo. Cada lado decide se é um golpe e, quando é. Cada conta é um nó. Cada transação Pix é uma aresta com um valor e um registro de data e hora. O grafo ficará na

10:32 memória como listas de adjacência no formato CSR, certo? Além disso, estou mencionando aqui uma série de coisas, dizendo que os dados estão na pasta /data, em quatro arquivos, e que esses arquivos são mensagens, transações e assim por diante. Entenderam? Então, todos os detalhes estão aqui. Além disso, estou dizendo mais uma coisa, que coloquei aqui, olha só. Vou incluir um arquivo .env com a chave da API da Type Safety e a chave da API do DeepSeek, certo? Tanto o Rust quanto o

11:06 Python devem carregar este arquivo .env, certo? Ah, e nunca coloquem as chaves diretamente no código, tudo bem? Isso é importante. Então, vou enviar essas informações para ele aqui, e ele vai começar a construir o aplicativo completo para nós. Na pasta, já estou trazendo os arquivos para cá, certo? Enquanto isso, os arquivos de dados estão sendo criados, e estou trazendo as informações de cada um. Aqui estão as chaves, as mensagens e todo o resto. Lembrando que tenho 10 milhões de transações e mais de 1.000

11:37 contas aqui, certo? Dentro dessas mensagens, que são 1.000, há 75 mensagens fraudulentas, certo? E ele terá que procurar essas mensagens fraudulentas e rastrear todas as fraudes relacionadas às contas. No Reversa New, na parte expressa, estou fazendo isso rapidamente, usando a parte expressa do Reversa New. Recomendo que, se o seu software for maior, é interessante construí-lo no modo normal, guiado,

12:09 certo? Mas, como o software aqui é relativamente pequeno, vou criá-lo no modo expresso. E, nesse modo expresso, há oito etapas, certo? Essas etapas serão executadas sem parar. Só preciso dizer para começar aqui, certo? E ele começará a executar, sem parar, todas as etapas dos agentes internos do Reversa New. Quando terminar, todas as especificações estarão prontas para o desenvolvimento. Então, só precisamos chamar o Reversa Forward, que fará o desenvolvimento propriamente dito, tanto em Rust quanto em Python.

12:41 Muito bem, o Reversa concluiu todo o processo. Agora chamei o Reversa Forward, certo? Vamos continuar. E agora ele vai começar toda a parte de programação propriamente dita do aplicativo Pix, certo? Para detectar fraudes no Pix. Tudo bem? Certo. Quando terminar, vou pedir ao Claude para iniciar o servidor. Vou falar diretamente com ele aqui, olha só. Claude, quero que você inicie o servidor que criamos para detectar fraudes no Pix usando Rust e

13:13 Python com DeepSeek. É só enviar. Agora, olha só que interessante. Aqui em src/rust e também rodando aqui, temos os códigos Python em py_worker, certo? Com DeepSeek e todos os requisitos definidos para executar Python junto com Rust na mesma página, certo? Temos uma página estática aqui; este index vai chamar os dois backends, certo? E vai mostrar

13:43 exatamente o aplicativo de detecção de fraudes na tela. Muito bem, o aplicativo já está no ar aqui, rodando em localhost 8080. Então, vou copiar o endereço aqui, certo? Vou abrir este navegador aqui, certo? E vou acessar localhost 8080. Vocês podem ver que o aplicativo está rodando aqui, certo? Tudo bem? Exatamente como pedimos ao nosso querido Claude, certo? E reparem que, se eu clicar em iniciar aqui, no modo de velocidade normal,

14:15 vai acontecer exatamente o que previmos em relação à execução do detector de golpes com Rust e Python com DeepSeek. Tudo bem? Vou deixar este aplicativo em um lugar específico, mas, se quiserem executá-lo em casa, basta entrar no nosso grupo do WhatsApp e pedir o aplicativo; vocês poderão acessá-lo gratuitamente. Tudo bem? É isso, pessoal. Acho que o conceito sobre a velocidade do GGUF em relação ao DeepSeek ficou bem claro, certo? Mas

14:45 também é importante ter uma linguagem de programação que chegue bem perto da velocidade do GGUF, porque, caso contrário, a própria linguagem de programação pode limitar a velocidade do modelo. Tudo bem? Espero que tenham gostado deste vídeo. Vou deixar aqui mais dois vídeos interessantes sobre inteligência artificial. Um grande abraço e até a próxima. Não se esqueçam de deixar uma curtida, de se inscrever no canal, de compartilhar e de deixar um comentário sobre este aplicativo. Um grande abraço e até a próxima.

Transcrição original

[00:01] Today I will build with you using Reversa, an application based on the Jev model, combined with the supersonic Rust language for the task of real-time fraudulent Pix detection. Our database has 10 million transactions, 1 million accounts, and over 1,000 WhatsApp messages. And we will compare the performance of this application against an application also built with Python and DeepSeek. It is artificial

[00:32] intelligence in supersonic mode. Hello, how are you doing? I am Sandeco. I am a professor and researcher at the Federal Institute of Goiás and the Federal University of Goiás. And I have been talking about artificial intelligence here on YouTube for almost 10 years. And if you like information with uncomplicated artificial intelligence, but without losing technical quality, I hope you consider subscribing to my channel. Turn on notifications so you

[01:06] don’t miss any news, and if you want to talk to me personally, there is a WhatsApp group with the link down here in the description that you can join with us, okay? All right, this here is our scam detector. This pink one here is Rust with Jev. And here is Python with DeepSeek, in the colors of Jev and DeepSeek. The first important thing we see here, folks, is the amount of memory used by each programming language. Look right here. In Rust, the memory usage was at 128 MB to load the

[01:36] data into memory. And here in Python, it’s 1.6 GB. Just there you can see the consumption and optimization of the language itself. Up here, I have two interesting options, which are narrated in 4 seconds and normal. This narrated mode will show a message, we will be able to see it for 4 seconds, and then it moves to the next, to the next, and the next. But when we start processing, we can normally switch here to the normal pace, and it starts processing in an accelerated way. So let’s start

[02:07] here by clicking start in narrated mode , and you see that both start processing equally, and Rust already starts to be a little faster, do you see? In this process. So, what I’m going to do here is the following. You see these are the messages being sent, right? Uh, so far no scam message has appeared. Whoa, a scam appeared here. And I can come down here, look, come down here and check the scam, look. Do you see? If I click here, look how interesting, it places exactly this graph here, because this graph is the

[02:38] relationship between the accounts to be able to find the scam. If I click on the scam here, specifically, see, I can view the details, right? The classification he set there as a fake payment slip, okay? Jeev’s decision in 345 milliseconds and Rust’s internal processing in 27 ms, okay? OK. See how fast it is, the combination of these two languages is very fast. In a bit, I’ll show you how these speeds compare with DeepSeek and Python. But down here

[03:10] , it shows all the scam probabilities, right? Whether it asks for Pix or not, if it shows urgency or confidence, okay ? OK. Here we have the model and the cost, right, in terms of tokens. And down here, I have the cost in dollars for the decision and the messages. On the right side, it’s cool that we can see, right? When you hover the mouse over the entity up here, we can see the origin, the accounts, which are the mule accounts, where the money was sent , right? To get the suspect down here,

[03:41] which is the final withdrawal account of the guy who is robbing you, let’s say. And down here, there are also the mule accounts and the withdrawal account, okay? OK. So, if I close this, I already have a scam here, see, that was found, the same scam here. You can see it’s the same scam, see, it was found by DeepSeek. Got it? So, if I click here, you see the difference. Look at the difference. First, DeepSeek , in almost 1 second, that is, three times slower, okay? And here, the Python trace was 300 milliseconds, that

[04:12] is, 10 times slower, understand? It’s no use just combining Jeev with any language. The cool thing is to combine it with a super fast language, like Rust. And now what I’m going to do up here, I’ll take, you see the difference , it’s very close, right? But if I set it to normal, you will start to notice the monstrous difference compared to Rust with Jeev versus Python. Look at how it accelerates, folks, how fast

[04:43] Jeev with Rust really is. And every time a scam appears, the screen flashes for us and everything, and the sequences of scams being detected by the system start appearing down here. I’ll let it run until the end and speed up the video so you can see how different the processing is between Rust with Jev and Python with DeepSeek. Let’s go. At this point, guys, we have Rust finished processing, right? All

[05:15] 1,000 messages, okay? Remember that these processes here, guys, are linear processing. I didn’t open processing threads. I could have opened, say, four threads, five threads, right? To perform this processing in parallel, which would be much faster. But since I wanted to analyze, in a raw way, let’s say, the two languages and the two models, right? I left it in a linear format. See that I already processed 1,000 messages here with Rust, and when

[05:46] we stopped, it was at 300 and something messages, right? In other words, Rust with Jev was three times faster than Python with DeepSeek, okay? At least that, right? And this is without using any parallel processing. I’ll let it finish here with DeepSeek so you can see and get an idea of the total time it takes for both the Rust and Python processing, as well as Rust with Jev, okay? OK. Alright, the process is

[06:18] finished and we will now see the accuracy report, right? I have the total time for Jev here at 307 seconds and the total time for Python at 1,047 seconds. Look at the difference, it’s huge, right, guys? Here is the time, right, by median, this P50 is the 50th percentile, meaning half of the decisions took 298 milliseconds. However, I have decisions that took longer than that, but on average, right

[06:48] ? 298 milliseconds for Jev and I have 25 milliseconds for Rust tracking, while the DeepSeek decision took something around, uh, 1 second, more than 1 second, right? 1,027 milliseconds, got it? And the Python tracking is 243 milliseconds. You see that here you have a value almost three times higher, okay? And here, in comparison between Rust and Python,

[07:21] it’s almost 10 times faster processing, okay? Then there is the accuracy here, actually there are 75 scams injected into the database, okay? Rust with Jev actually managed to detect 74 scams, one less, right? And Python managed to detect all 75. So this is very important information, because there is a small drop in accuracy here regarding Jev, okay? It was the only point where

[07:53] Python comepsic won in cost. And here I have, look, 0.025 of a dollar and here cents of a dollar, 1/4 of the value. This is very powerful. All right? Very well. Now I will show you how I built this application using the new Reversa agent called Reversa New. Not exactly new, right? People are already using it a lot out there, but this is the first time I’m talking about Reversa New here

[08:23] on the Sandeco channel. It’s for creating applications from scratch using the Reversa framework. Let’s go. I’m already here in a folder inside VS Code called Pix Golp, okay? with cloud code open here, with the cloud code extension for VS Code, right? I’ll close this and now I’ll press Ctrl + J and ask to install Reversa, okay? With this command, right? NPX Reversa install. Well, here in Reversa you already know it, right? In Reversa you will come here and choose which hardness you want to use. I’ll use it here, right? I’ll tell it to leave it

[08:54] installed here, look. There’s even the new Herms here, right? For you to be able to use as well, but I’ll basically activate it for cloud Code Codex, okay? I’ll put the name here as Pix Golp, my name Sandeco, then Portuguese as the language for the specifications or specs, and I’ll say I want to chat, right, to resolve issues directly in the chat. After installation, it’s good to restart the session and run reversa new, dash new. What does this reversa new do? It builds applications from scratch. It will guide you through the

[09:27] construction of an application from scratch with you. Then it will ask this , right? How do you want to run reversa new? Will it be guided, meaning we will talk detail by detail about how this software will be, or express. You want to build it very quickly. I will choose express here, okay? Because I want to build this application very quickly, especially since this application is very simple, the idea is very simple. It asked me here, right, in express mode, for me to say what I want to build. And so I wrote a whole prompt

[09:59] here, folks. quite detailed about what I’m looking for. I’ll just briefly read what I want, right? I want to build a split-screen demo to show live, detecting a Pix scam, tracking the money’s path to the gang. On the left side, Rust runs with Type Safety AI’s JV, and then Python runs with DeepSeek. The same messages in Portuguese enter both sides at the same time. Each side decides whether it is a scam, and when it is. Each account is a node. Each Pix transaction is an edge with a value and timestamp. The graph will stay in

[10:32] memory as adjacency lists in CSR format , right? So, besides that, I’m mentioning a series of things here, saying the data is inside the/data folder in four files, and these files are messages, the files are transactions, and so on. Got it? So, all the details are here. Furthermore, I’m telling it something else that I put here, look. I will include a .env file with the Type Safety API key and DeepSeek API key, okay? Both Rust and

[11:06] Python should load this .env, right? Ah , and never hardcode the keys in the code, all right? This is important. So, I will send this information to it here , and it will start building the complete application for us. In the folder, I’m already bringing the files over here, okay? While it’s building the data files, which I’m bringing over as information for each. So, here are the keys, the messages, and everything else. Remembering that I have 10 million transactions and over 1000

[11:37] accounts here, okay? Inside these messages, which are 1000 messages, there are 75 fraudulent messages, okay? And it will have to search for these fraudulent messages and track all the fraud in relation to the accounts. In Reversa New, in the express part, I’m doing it quickly, the express part of Reversa New. I recommend, if your software is larger, it’s interesting to build it in the normal, guided mode,

[12:09] okay? But since the software here is somewhat small, I will create it. I am creating it in express mode. And in this express mode, it has eight stages, right? And these stages will execute non-stop. I just need to say start here , okay? And it will start executing all the stages of the Reversa New internal agents non-stop. After it finishes, all specs will be ready for development. And then, we just need to call Reversa Forward, which will do the actual development, both in Rust and Python.

[12:41] Very well, Reversa has completed the entire process. Now I have called Reversa Forward, right? Let’s continue. And now it will start the entire actual programming part of the Pix application , right? For Pix fraud. All right? OK. Once completed, I’ll now tell Claude here to start the server. So I’ll speak to him directly here, look. Claude, I want you to start the server we created for Pix fraud detection using Rust and

[13:13] Python with DeepSeek. Just send it. Now , look how interesting this is, right? Here in src/rust and also running here, we have the Python codes. here in py_worker, okay? With DeepSeek and all the requirements defined to run Python alongside Rust on the same page, okay? We have a page that will be the static page here, this index will call both backends, okay? And it will show

[13:43] exactly the fraud detection application on the screen. Very well, the application is already live here running on localhost 8080. So I’ll copy it here, right? I’ll bring this browser over here, right? and I’ll run localhost 8080 here. You can see that the application is running here, right? All right? Just the way we asked our dear Claude, right? And notice that if I hit start here, in normal speed mode,

[14:15] exactly what we predicted regarding the execution of the scam detector with Rust and Python DeepSeek will happen. All right? I will leave this application in a specific place, but if you want to run this application at home, just join our WhatsApp group and ask for the application, and you can access it for free. All right? That’s it, folks. I think the concept was quite clear, right, about the speed of GGUF in relation to DeepSeek, but it’s

[14:45] also important to have a programming language that comes very close to the speed of GGUF, because otherwise, the programming language itself might limit the speed of the model. All right? I hope you enjoyed this video. I’ll leave two more interesting videos here in the artificial intelligence field. A big hug to you and until next time. Don’t forget to leave a like, don’t forget to subscribe to the channel, share, and leave your comment about this application. A big hug and until next time.