JEV+RUST vs Python+Deepseek: Detectando fraudes no Pix em tempo real!

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: JEV+RUST vs Python+Deepseek: Detectando fraudes no Pix em tempo real! · Channel: Sandeco · 14:45 · Watch on YouTube

Topics: AI evaluation and benchmarks, Cybersecurity and software security, Software engineering with AI, AI models, Open source and software ecosystems

Summary

Sandeco demonstrates a Pix fraud-detection app that processes the same messages with Rust and Jev on one side, and Python and DeepSeek on the other. In the reported test, Rust with Jev processed all 1,000 messages in 307 seconds, compared with 1,047 seconds for Python with DeepSeek; Jev detected 74 of the 75 injected scams, while DeepSeek detected all 75. The video also walks through building the app with Reversa New and Reversa Forward, then running it locally. Sandeco concludes that a fast model needs a suitably fast programming language so the language itself does not limit performance.

Key points

The demo compares Rust with Jev against Python with DeepSeek on the same set of 1,000 messages.
The dataset is described as containing 10 million transactions, 1 million accounts, and more than 1,000 WhatsApp messages.
The displayed memory use was 128 MB for Rust and 1.6 GB for Python.
The application visualizes suspected scams and account relationships, including the path of money through mule accounts to a withdrawal account.
Processing was linear rather than parallel, and Rust with Jev finished in 307 seconds versus 1,047 seconds for Python with DeepSeek.
The median decision times were reported as 298 milliseconds for Jev and 1,027 milliseconds for DeepSeek; tracking took 25 milliseconds in Rust and 243 milliseconds in Python.
Of 75 injected scams, Rust with Jev detected 74, while Python with DeepSeek detected all 75.
The presenter uses Reversa New in express mode to specify and generate the application, then Reversa Forward for implementation.
The app loads API keys from a .env file rather than hardcoding them and runs locally at localhost:8080.

Chapters

Start	Chapter	Summary
00:01	Introducing the Pix fraud-detection comparison	Sandeco introduces the app, dataset, and comparison between Rust with Jev and Python with DeepSeek.
01:06	Live demo and performance comparison	The app displays detected scams and account graphs as the presenter compares processing speed and accuracy.
08:23	Building the app with Reversa	Sandeco explains the Reversa New setup, the express-mode prompt, the data requirements, and the development workflow.
12:41	Running the application and closing remarks	Reversa Forward completes the implementation, the app runs locally, and Sandeco reflects on the importance of a fast programming language.

Quotes

Rust with Jev was three times faster than Python with DeepSeek — 05:46

the total time for Jev here at 307 seconds and the total time for Python at 1,047 seconds. — 06:18

Rust with Jev actually managed to detect 74 scams, one less, right? And Python managed to detect all 75. — 07:21

the programming language itself might limit the speed of the model. — 14:45

Concepts and entities

Jev, DeepSeek, Rust, Python, Reversa, Reversa New, Reversa Forward, Claude Code, Sandeco, GGUF

Full transcript (original language)

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.