Hy-Memory-30B-A3B + Hy Memory: escritor de memória local para agentes de IA

Autoria: Fahd Mirza · Assistir no YouTube

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: Hy-Memory-30B-A3B + Hy Memory: Local Memory Writer for AI Agents · Canal: Fahd Mirza · 07:52 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Modelos locais e open source

Resumo

O vídeo apresenta o Hy-Memory-30B-A3B, modelo da Tencent Hunyuan especializado em decidir quais memórias de agentes de IA guardar, atualizar ou substituir, e o Hy Memory, mecanismo e SDK de memória. O apresentador instala o SDK e conecta o modelo, servido localmente por vLLM, para testar a atualização de um fato: Alex mudou-se de Seattle para Sydney. O teste mostra que o sistema substitui a memória antiga, atualiza o perfil e registra o motivo da mudança. O vídeo também menciona a licença Apache 2.0, uma integração com OpenClaw, resultados de benchmarks e o processo de treinamento do modelo.

Pontos-chave

O Hy-Memory-30B-A3B tem cerca de 3 bilhões de parâmetros ativos e foi treinado para escrever memórias.
O Hy Memory é o mecanismo de memória e SDK da Tencent; o modelo atua como escritor das memórias.
O sistema extrai fatos de conversas, compara-os com memórias existentes e pode substituir informações desatualizadas.
No teste, a memória de que Alex morava em Seattle foi substituída pela informação de que ele se mudou para Sydney.
O sistema também atualizou a memória relacionada ao emprego para preservar o histórico.
O apresentador executou o modelo localmente com vLLM em uma GPU NVIDIA H100 com 80 GB de VRAM.
As memórias são convertidas em embeddings e, no exemplo, o armazenamento usa SQLite.
O projeto é disponibilizado sob a licença Apache 2.0, e o vídeo menciona integração com OpenClaw.
No benchmark mostrado, Hy Memory obteve pontuação geral de 55,49, superando Claude Opus 5 e DeepSeek V4.1.
O treinamento descrito tem duas etapas: supervisão de um modelo professor e reinforcement learning para avaliar o banco de memórias.

Capítulos

Início	Capítulo	Resumo
00:01	Apresentação do modelo e do sistema de memória	O vídeo introduz o Hy-Memory-30B-A3B e o Hy Memory como modelo escritor e mecanismo de memória para agentes.
02:08	Instalação e funcionamento do Hy Memory	O apresentador instala o SDK e explica como o sistema extrai fatos, compara memórias existentes e atualiza informações.
03:45	Teste local de atualização de uma memória	O modelo é conectado ao Hy Memory e testado com a mudança de Alex de Seattle para Sydney.
05:18	Resultados, benchmarks e treinamento	O vídeo mostra como a memória antiga é substituída, apresenta resultados de benchmark e resume as duas etapas de treinamento.

Citações

O modelo é o escritor e este é o caderno. — 00:33

Se um fato mudou, o antigo é substituído. — 03:11

O modelo não simplesmente empilha uma nova anotação sobre a antiga. — 05:48

O modelo é ensinado a fazer o trabalho real de manter um banco de memórias correto ao longo do tempo. — 07:20

Conceitos e entidades

Hy-Memory-30B-A3B (modelo): Modelo da Tencent Hunyuan apresentado como especializado em extrair, atualizar e substituir memórias para agentes.
Hy Memory (ferramenta): Mecanismo de memória e SDK que organiza a extração, reconciliação, armazenamento e busca de memórias.
Tencent Hunyuan (empresa): Organização associada ao modelo Hy-Memory-30B-A3B e ao Hy Memory.
vLLM (ferramenta): Ferramenta usada pelo apresentador para servir o modelo localmente.
NVIDIA H100 (modelo): GPU com 80 GB de VRAM usada na demonstração para executar o modelo.
SQLite (ferramenta): Banco de dados mencionado como parte do armazenamento usado pelo sistema.
OpenClaw (ferramenta): Ferramenta citada como possível integração para o Hy Memory.
Apache License 2.0 (conceito): Licença sob a qual o projeto é disponibilizado, segundo o apresentador.
Claude Opus 5 (modelo): Modelo citado como comparativo no benchmark apresentado.
DeepSeek V4.1 (modelo): Modelo citado como comparativo no benchmark apresentado.

Tradução completa (pt-BR)

00:01 Já existem ferramentas de memória para agents de IA. Mem0, MemOS e outras. Mas todas dependem de um LLM geral para decidir o que lembrar. A Tencent acabou de disponibilizar como open source um modelo treinado para essa única tarefa, com cerca de 3 bilhões de parâmetros ativos. Hoje, vamos instalá-lo e testá-lo localmente com um caso de uso do mundo real. Aqui é Fahad Mirza, e dou as boas-vindas a você ao canal. Então, o que exatamente é esse modelo? É o

00:33 Hy-Memory-30B-A3B, da Tencent Hunyuan. Ele substitui o LLM geral dentro de frameworks de memória e decide o que manter e como atualizar. Além disso, este é o Hy Memory, o próprio mecanismo de memória e SDK da Tencent. O modelo é quem escreve, e isto é o caderno. Vamos instalar os dois. Vou direto ao terminal, onde estou usando o Ubuntu. Tenho uma placa de GPU Nvidia

01:05 H100 com 80 GB de VRAM, que está consumindo quase 75 GB neste momento, porque já estou executando e disponibilizando este modelo no meu sistema local com vLLM, como vocês podem ver aqui. Se não sabe como instalar o vLLM, é só procurar no meu canal. E o motivo de ele estar consumindo tanta VRAM é este comprimento máximo do modelo. Se você diminuir esse valor, o consumo de VRAM cai. Se está procurando alugar uma GPU por um preço muito bom,

01:36 você encontra o link para a Mass Compute na descrição do vídeo. E aqui está a melhor newsletter sobre IA do mundo, enviada semanalmente só para você. Então, assine em fahadmirza.substack.com. E, se quiser ajudar o canal, torne-se membro, pois isso ajuda bastante. Agora você já sabe o que está acontecendo e o que está sendo executado. Vou voltar ao terminal, onde estou usando esta placa de GPU. Agora, vou

02:08 instalar o SDK, que é essencialmente o Hy Memory. É um único comando com UV pip, e isso já foi feito. Então, como veem, o modelo já está instalado e em execução, e agora também instalamos o Hy Memory. Antes de continuar, vou explicar o contexto. Entendam o que vamos fazer em seguida. Vamos conectar o SDK Hy Memory ao nosso modelo local, certo? Depois, vamos informar alguns

02:40 fatos sobre algo, alterar um desses fatos e fazer uma busca para ver se ele se lembra da nova versão. Isso vai nos mostrar se o modelo realmente cumpre a função de escrever as memórias. Para entender exatamente como tudo se encaixa, observem este diagrama. Ele mostra o que acontece dentro do Hy Memory quando fazemos isso. Toda chamada começa no topo: adicionar, para salvar algo; buscar, para recuperar algo.

03:11 Quando adicionamos uma conversa, um LLM a lê e extrai os fatos que vale a pena guardar, e uma etapa de reconciliação os compara com o que já está armazenado. Se um fato mudou, o antigo é substituído. Essa é a parte em que nosso modelo entra em ação. Quando fazemos uma busca, as memórias armazenadas são recuperadas, e as relevantes são retornadas. Então, quando executarmos nosso teste, vocês saberão exatamente qual etapa faz o quê. Vamos voltar e executar isso.

03:45 O primeiro comando que precisamos executar é este, que direciona o escritor do Hy Memory ao nosso servidor vLLM local. Pronto. Em segundo lugar, vou precisar de um modelo de embedding, porque as memórias armazenadas são salvas como vetores ou embeddings. Para isso, vocês podem usar um modelo local ou uma API. Vou usar a API DashScope da Alibaba, só para facilitar. Mas, como eu disse, vocês podem usar qualquer modelo local que preferirem. Isso também está pronto. Agora,

04:17 com isso feito, escrevi um script bem curto para demonstrar. Deixem-me mostrar. Observem este script. Ele basicamente cria um cliente do Hy Memory no modo Pro, que usa um LLM para extrair e reconciliar memórias. Ele adiciona o fato de que Alex mora em Seattle e, em seguida, adiciona uma atualização dizendo que Alex se mudou para Sydney. Depois, busca onde Alex mora, para vermos se o fato novo substituiu o antigo ou

04:47 não. Vou voltar e executar o script agora. Pronto. Foi executado bem rápido, mas produziu muitos dados, e tudo isso mostra o que o Hy Memory fez em uma única chamada. Vou percorrer os resultados. Não se preocupem, vou explicar o que aconteceu aqui. Como veem, ele está gerando embeddings do texto, ou seja, convertendo essas memórias em representações numéricas, embeddings ou vetores. Fez o modelo extrair os fatos e compará-los com o que está

05:18 armazenado e, depois, salvá-los. A extração detectou a mudança de Seattle para Sydney. E ele já está processando, processando, processando, processando. Fez muitas coisas. Nos bastidores, está usando principalmente o SQLite leve. Certo, vou reduzir os resultados. Usei o grep com esse resultado para mostrar o que é relevante aqui. Então, como veem, informamos que

05:48 Alex mora em Seattle, certo? Vou descer um pouco para mostrar que ele adicionou os dois fatos que usamos no script: a localização e o trabalho. Depois, também informamos que ele se mudou para Sydney. E este é o momento importante. O modelo não simplesmente empilha uma nova anotação sobre a antiga. Ele decide que a memória sobre Seattle está errada e emite uma substituição, explicando o motivo: o usuário se mudou de Seattle para Sydney e já não mora em Seattle. Ele também atualiza

06:19 a memória sobre o trabalho para preservar o histórico. E vejam que o perfil na parte inferior agora diz que Alex mora em Sydney. Então, este é um modelo com 3 bilhões de parâmetros ativos decidindo o que manter, o que substituir e o que levar adiante. Isso é bastante impressionante. E o ótimo é que disponibilizaram tudo como open source, o que é sempre muito bem-vindo. Licença Apache 2. Como não gostar? Dá até para integrá-lo ao OpenClaw ou a qualquer outro agent de programação,

06:50 também. Acho que a integração com o OpenClaw em escala já está disponível no repo deles no GitHub. Antes de encerrar, quero mostrar mais uma coisa rapidamente. Eles compartilharam alguns benchmarks. Observem este diagrama: testaram quatro escritores de memória na mesma configuração. A única coisa que mudou foi qual modelo escreveu as memórias. E vocês podem ver que o Hy Memory, este aqui, obteve 55,49 no total, à frente do Claude Opus 5, do DeepSeek V4.1 e do

07:20 QwenNet, de tamanho semelhante, que marcou 50,37. Muito legal. Vou mostrar rapidamente a configuração de treinamento. Ela tem duas etapas. Na primeira, o modelo estudante escreve memórias, e um modelo professor Hunyuan H3 congelado verifica cada etapa que ele executa. Na segunda, o aprendizado por reforço avalia o banco de memórias após cada trecho, usando um modelo de resposta congelado e um avaliador. O melhor banco é mantido para a etapa seguinte. Assim, o modelo é treinado na tarefa real de manter um

07:52 banco de memórias correto ao longo do tempo. Então, vejam: é realmente impressionante, com uma licença muito permissiva e generosa. Acho que vou usar essa ferramenta no meu ambiente de produção com meu cliente. Fiquem à vontade para conferir. Digam o que acharam. E, mais uma vez, tornem-se membros e assinem a newsletter. Obrigado por todo o apoio.

Transcrição original

[00:01] Memory tools for AI agents already exist. Mem zero, Mem OS and others. But they all lean on a general LLM to decide what to remember. Tencent just open-sourced a model trained for that one job with about 3 billion active parameters. Today we are going to install it, test it locally with a real-world use case. This is Fahad Mirza and I welcome you to the channel. So what exactly is this model? This is

[00:33] high memory 30 billion A3B from Tencent Hunyuan. It replaces the general LLM inside memory frameworks and it decides what to keep and how to update it. Not only that, this is high memory Tencent’s own memory engine and SDK. The model is the writer and this is the notebook and we are going to install both of these. I’ll straight away take you to my terminal where I’m running this Ubuntu. I have one GPU card Nvidia

[01:05] H100 with 80GB of VRAM which is consuming almost 75 gig gig at the moment due to the fact that I’m already running and serving this model on my local system with vLLM as you can see here. If you don’t know how to install vLLM, just search my channel and the reason why it is consuming so much VRAM is because of this max model length. You decrease this thing and that VRAM consumption comes down. If you’re looking to rent a GPU on very good

[01:36] price, you can find the link to Mass Compute in video’s description. And here is the world’s greatest ever newsletter about AI only served to you weekly. So please subscribe to it at fahadmirza.substack.com. And if you want to help out with the channel just please become a member as that helps a lot. So now you know what is happening what exactly is running. Let me take you back to my terminal where I am running this GPU card. Now, what I’m going to do, I’m

[02:08] going to install the SDK, which is primarily High Memory, and this is a single command with UV pip, and that is already done. So, you see, we have both the model installed and running, and now we have High Memory also installed. So, before I move forward, let me set the stage. So, just understand what we are going to do next. We are going to connect High Memory the SDK to our local model, right? Then we will tell it a few

[02:40] facts about something, change one of those facts, and search to see whether it remembers the new version or not. That is going to show us if the model really does its job as the memory writer or not. In order to understand how exactly it all fits in, look at this diagram. This diagram shows what happens inside High Memory when we do that. Every call starts at the top, add to save something, search to get something back.

[03:11] When we add a conversation, an LLM reads it and pulls out the facts worth keeping, and a reconcile step compares them with what is already stored. If a fact has changed, the old one is replaced. That LLM is the part of our model that takes over. When we search, the stored memories are recalled, and the relevant ones come back. So, when we run our test, you will know exactly which step is doing what. Let’s go back, and you know, run this thing.

[03:45] The first command we need to run is this, where we are pointing High Memory’s writer at our local VLLM server. That is done. Second, I would need an embedding model because whatever memory is stored, it stores as a vector or embedding. For that, you can either use a local one or you can use an API based one. I’m just going to use the test scope API from Alibaba just to make things easier. But as I said, you can use any local model of your choice. That is also done. Now,

[04:17] once that is done, I have just written a very short script to demonstrate that. Let me show you. So, look at this script. This script basically creates a high memory client in pro mode, which is the mode that uses an LLM to extract and reconcile memories. It adds a fact that Alex lives in Seattle and then adds an update that Alex moved to Sydney. Then searches for where Alex lives, so we can see whether the new fact replaced the old one or

[04:47] not. So, let me go back and then run this script now. And there you go. Ran very quickly, but produced a lot of data and everything it shows which high memory it did behind one at call. So, I’ll just scroll through. Don’t worry, I’m going to explain what happened here. So, you see, um it is embedding the text, which is which means converting those memories into numerical representations or embeddings or vectors. Have the model extract facts, compare them with what is

[05:18] stored, then save. The extraction picked up the Seattle to Sydney move. Um and then, you know, it is already going through through through through through through. And lot of things it has done. So, behind the scene, primarily it is using that lightweight SQLite. Okay, so let me actually trim it down. So, I have just used grep with that result just to show you what exactly is relevant here. So, you see, we tell it

[05:48] Alex lives in Seattle, right? And then I’ll just scroll down to show you it has added both of the facts which we used in the script, the location and the job. And then we told it the fact too that it has uh he has moved to Sydney. And this is the moment that matters. The model doesn’t just pile a new note on top of the old one. It decides the Seattle memory is now wrong and issues a supercede with its own reason written out. The user moved from Seattle to Sydney and no longer lives in Seattle. It also updates

[06:19] the job memory to carry the history along. And you see that profile at the bottom now says Alex lives in Sydney. So, this is a 3 billion active parameter model deciding what to keep, what to replace, and what to carry forward. So, this is quite impressive. And the great thing is that they have open sourced it all, which is always always welcome. Apache 2 license. How good is that? You can even integrate it with Open Claw or any other coding agent,

[06:50] too. I think Open Claw integration at a scale is already there in their GitHub repo. Before I wrap up, let me show you quickly one more thing. They have shared few of the benchmarks. So, if you look at this diagram, they tested four memory writers on the same setup. And the only thing that changed was which model wrote the memories. And you can see High Memory, this one, scored 55.49 overall, which is ahead of Claude Opus 5, DeepSeek V4.1, and the

[07:20] size mashed Qwen net 50.37. Really really cool. Um let me very quickly show you the training setup. So, it has two stages. It’s in stage one, the student model writes memories and a frozen H High 3 teacher checks every step it takes. In stage two, reinforcement learning scores the memory bank after each chunk using a frozen answer model and a judge. And the best bank carries forward. So, the model is taught on the real job of keeping a

[07:52] memory bank correct over time. So, look. Um really impressive, very very liberal and generous license. I think I will be using this tool in my production environment with my client. So, feel free to check it out. Let me know your thoughts. And again, please become a member and do subscribe to that newsletter. Thank you for all the support.