<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by André Coelho on Medium]]></title>
        <description><![CDATA[Stories by André Coelho on Medium]]></description>
        <link>https://medium.com/@andre.luiz1987?source=rss-9e072dc02cd------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*o8ksn3c4evllr-ZY.</url>
            <title>Stories by André Coelho on Medium</title>
            <link>https://medium.com/@andre.luiz1987?source=rss-9e072dc02cd------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 01:14:37 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@andre.luiz1987/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your RAG retrieves the right document, but ranks it in the wrong position]]></title>
            <link>https://medium.com/@andre.luiz1987/your-rag-retrieves-the-right-document-but-ranks-it-in-the-wrong-position-55e77e30e4b3?source=rss-9e072dc02cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/55e77e30e4b3</guid>
            <category><![CDATA[vector-search]]></category>
            <category><![CDATA[reranker]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[jevs]]></category>
            <dc:creator><![CDATA[André Coelho]]></dc:creator>
            <pubDate>Fri, 23 Oct 2026 13:47:36 GMT</pubDate>
            <atom:updated>2026-10-23T13:47:36.841Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How a reranker with probabilistic scores raised P@1 from 74% to 92%, and what it cost in latency.</em></p><p>Your RAG system can find the right information and still start with the wrong context. When a merely similar document ranks first, it increases the chance that the answer will head in the wrong direction.</p><p>That is what we found: in 26% of queries, the first result was not relevant. The useful information was in the list, but not at the top.</p><p>To fix the ordering, we added a reranking step with Jev. P@1 increased from 0.740 to 0.920, and nDCG@5 rose from 0.729 to 0.916, a gain of about 25%. In the environment where we measured it, the step added roughly 0.95 seconds at p50. This article explains what we did, when that cost is worth paying, and which limitations remain.</p><h3>Why rerank, and how we define the score</h3><p>Vector search is fast because it works over precomputed vectors. It finds texts about the same topic, but not necessarily the text that answers the question. “How do I pay a Pix using a QR Code?” and “How do I authorize Pix Automático?” may be close in vector space even though only one answers what the person asked.</p><p>Reranking comes after retrieval. The retriever returns a short list, ten candidates in this case, and a model reads the question and each candidate together to change their order. This is the classic use of cross-encoders (<a href="https://arxiv.org/abs/1901.04085v1">Nogueira and Cho, 2019</a>).</p><p>We used <a href="https://docs.typesafe.ai/models">TypeSafe’s Jev</a>, pinned to version jev-1.13.0, with a three-level rubric:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3QDfOc7sFtMLSUdtJKx-WQ.png" /></figure><p>For each candidate, the model returns probabilities p0, p1, and p2. We use them to calculate a ranking score:</p><pre>score_norm  = (0·p0 + 1·p1 + 2·p2) / 2</pre><p>score_norm is the expected level, normalized between 0 and 1. It is the reranker&#39;s score: the higher it is, the higher the candidate ranks in the list.</p><p>This rubric separates a text that is merely related from one that actually solves the question, instead of relying on topical similarity alone.</p><h3>How reranking changes the result order</h3><p>After the initial retrieval, the reranker receives the question and the short candidate list. In one call, it evaluates every item against the same rubric, calculates score_norm, and returns the list in descending score order. In code, the flow is:</p><pre>candidates = retriever.search(question, k=10)<br>ranked = reranker.rerank(question, candidates)</pre><p>Each candidate is evaluated independently against the question, but all candidates are sent in the same request. The output contains the probabilities for rubric levels 0, 1, and 2. We use them to calculate the score_norm shown above and determine each item&#39;s new position.</p><p>score_norm can also be used as a cutoff within the reranker:</p><pre>ranked = rerank(question, candidates, min_score=threshold)</pre><p>Candidates below the chosen value are not returned. If none pass, the application can choose not to send context to the model or ask for clarification. This cutoff must be validated for each domain: it lowers the chance of including weak context, but may also exclude useful documents. In this experiment, we used reranking only, with no cutoff.</p><p>The reranker does not retrieve new documents or alter candidate text. It only changes the order of items already returned by the retriever. If the first search result is merely related and the third one actually solves the question, the third result tends to move to the top.</p><h3>How we measured it</h3><p>Before the main experiment, we ran an offline validation on a support-article corpus, with queries written as customers would write them and the first ten results from vector search, labeled from 0 to 2. This stage defined the rubric and scoring method.</p><p>In the main evaluation, we used 100 queries and the system’s vector retriever to measure the effect of reranking on result order.</p><ul><li>We evaluated 100 queries, with document-level relevance judgments.</li><li>The baseline is the retriever’s original order.</li><li>In the rerank arm, Jev reorders the ten candidates returned by the retriever, always using version jev-1.13.0.</li><li>Baseline and rerank use the same dataset and the same relevance judgments.</li><li>Recall@k is calculated over the 96 queries with at least one relevant candidate. In the other four, there is nothing to retrieve. Because reranking only reorders the same ten items, Recall@10 is the same in both arms.</li></ul><p>I built the relevance judgments with help from an AI model; there was no second human evaluator. The 100 queries were not used to tune the rubric or the score: both came from the offline validation and were applied unchanged.</p><p>For binary metrics, labels 1 and 2 count as relevant: P@1 asks whether the first result is relevant; MRR measures how early the first relevant result appears; P@k and Recall@k count relevant items in the top k. nDCG@k, in contrast, keeps the 0, 1, and 2 grades and assigns more value to a document that solves the question.</p><h3>Results: the gain is at the top</h3><p>Reranking improved the ordering metrics, especially where RAG is usually most sensitive: the first result and the top five.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aZF7V-fKDOkcz5NC8cgYMA.png" /><figcaption><em>Main evaluation, 100 queries. Baseline: vector retriever; rerank: reordering of the top ten candidates.</em></figcaption></figure><p>The gain was not limited to the first result. nDCG@5 increased from 0.729 to 0.916, and MRR from 0.815 to 0.935. P@3 and P@5 also improved, from 0.703 to 0.842 and from 0.646 to 0.768. Taken together, the metrics show that relevant documents appeared earlier in the list.</p><p>Recall@10 did not change. The reranker did not find new documents; it simply moved better candidates above worse ones.</p><p>The movement of the first relevant result shows how that gain was distributed across queries:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/758/1*N0dtTe1hx_SJovR3KjyyUg.png" /></figure><p>Among the 25 queries where the position changed, the first relevant result moved up in 21 and down in 4. The reranker improved the first relevant result’s position more than five times as often as it worsened it.</p><h3>The cost: latency needs context</h3><p>At p50, the query went from 0.79 s with search only to 1.74 s with search and reranking. The end-to-end difference was 947 ms at p50 and 1,406 ms at p95. This measures the added latency observed in that environment, not the model’s pure execution time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FwpcHl2d0pFZgVZesLgh0g.png" /><figcaption><em>Measured in a validation environment. The total is end-to-end latency; the percentiles of each stage do not add up exactly.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/742/1*aQI2ODkzcmENKRgMa4FhLw.png" /></figure><p>TypeSafe reports much lower latencies for Jev in its benchmarks, but a direct comparison does not fit here. In this experiment, the call went through a proxy, and the measurement includes that path in addition to the model. The numbers therefore indicate the trade-off for this pipeline in a validation environment, not Jev’s isolated latency or production latency.</p><p>The lesson is not to add a reranker to every pipeline. First, review the RAG flow, find the bottlenecks, and improve retrieval. Only then does it make sense to apply reranking and measure whether it improves the final result. Reranking reorganizes candidates that have already been retrieved; it does not replace well-designed search.</p><p>This cost makes sense when getting the first document wrong is expensive: automated RAG responses, customer support, and recommendation of a single article. In autocomplete, type-ahead search, or lists users explore on their own, the extra latency may not be worth it. Sending only the necessary candidates and more concise texts can also reduce this cost.</p><h3>Limitations and next steps</h3><p>The result is promising, but it does not settle the question.</p><ul><li>The sample has 100 queries. It shows the direction of the gain, but does not measure that gain with fine precision.</li><li>The relevance judgments were assisted by AI and had no second human evaluator. This may favor a reranker that also uses a model.</li><li>Latency was measured in a validation environment; it still needs to be measured in a setting closer to real use.</li><li>The rubric and score were defined for a support-article corpus. A different domain requires a new evaluation.</li></ul><p>Next steps are to measure latency in a setting closer to real use; compare with an open-source cross-encoder; measure the effect on the final RAG response; and review the relevance judgments with a second human evaluator.</p><h3>Conclusion</h3><p>Reranking does not fix poor retrieval. It solves a different problem: when search already finds useful information but does not place it where the system needs it.</p><p>That is what happened here. The retriever returned relevant candidates, but reranking increased the chance that the first result would answer the question. The next step is to confirm that gain in the final response, in a setting closer to real use.</p><p>The reranker’s score carries a useful distinction: a result can seem related and still fail to solve the question. That distinction helps place candidates most likely to provide good context at the top.</p><p>Comparisons with other models, an independent human evaluation, and production measurements are still needed. Even so, there is a practical conclusion: when retrieval is healthy but candidate order still gets in the way of the answer, reranking is one of the first places worth investigating.</p><h3>References</h3><ul><li><a href="https://docs.typesafe.ai/models">TypeSafe: Models</a>: Jev versions (jev-1.13.0) and why the version was pinned during the evaluation.</li><li><a href="https://typesafe.ai/">TypeSafe: published benchmark</a>: latency reference published by the vendor.</li><li>Nogueira and Cho, <a href="https://arxiv.org/abs/1901.04085v1">Passage Re-ranking with BERT</a> (2019): reranking with cross-encoders.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55e77e30e4b3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Seu RAG acerta o documento, mas na posição errada]]></title>
            <link>https://medium.com/@andre.luiz1987/seu-rag-acerta-o-documento-mas-na-posi%C3%A7%C3%A3o-errada-ff343e851fa3?source=rss-9e072dc02cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff343e851fa3</guid>
            <category><![CDATA[vector-search]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[jevs]]></category>
            <category><![CDATA[reranker]]></category>
            <dc:creator><![CDATA[André Coelho]]></dc:creator>
            <pubDate>Fri, 23 Oct 2026 13:41:06 GMT</pubDate>
            <atom:updated>2026-10-23T13:54:52.369Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Como um reranker levou o P@1 de 74% para 92% e qual foi o custo em latência.</em></p><p>Seu sistema de RAG pode encontrar a informação certa e ainda assim começar com o contexto errado. Quando um documento apenas parecido fica em primeiro lugar, ele aumenta o risco de uma resposta seguir a direção errada.</p><p>Foi o que vimos no nosso caso: em 26% das consultas, o primeiro resultado não era relevante. A informação útil estava na lista, mas não no topo.</p><p>Para corrigir a ordem, adicionamos uma etapa de rerank com o Jev. O P@1 foi de 0,740 para cerca de 0,92, e o nDCG@5 cresceu 25%. No ambiente em que medimos, a etapa acrescentou aproximadamente 0,95 segundo no p50. Este texto explica o que foi feito, onde esse custo compensa e quais limites ainda permanecem.</p><h3>Por que rerank e como definimos o score</h3><p>Busca vetorial é rápida porque trabalha sobre vetores já calculados. Ela encontra textos do mesmo assunto, mas não necessariamente o texto que resolve a pergunta. “Como pagar um Pix por QR Code” e “Como autorizar um Pix Automático” podem estar próximos no espaço vetorial, embora apenas um responda ao que a pessoa perguntou.</p><p>O rerank entra depois da busca. O retriever entrega uma lista curta, aqui de dez candidatos, e um modelo lê pergunta e candidato juntos para mudar a ordem. Esse é o uso clássico de cross-encoders (<a href="https://arxiv.org/abs/1901.04085v1">Nogueira e Cho, 2019</a>).</p><p>Usamos o <a href="https://docs.typesafe.ai/models">Jev, da TypeSafe</a>, na versão jev-1.13.0, com uma rubrica de três níveis:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ghUgY-0YM7AwbLtBo3DNCw.png" /></figure><p>Para cada candidato, o modelo devolve probabilidades p0, p1 e p2. A partir delas, calculamos um score de ordenação:</p><pre>score_norm  = (0·p0 + 1·p1 + 2·p2) / 2</pre><p>score_norm é o nível esperado, normalizado entre 0 e 1. Ele faz o papel de score do reranker: quanto maior, mais acima o candidato fica na lista.</p><p>Essa rubrica ajuda a diferenciar um texto apenas relacionado de um que realmente resolve a pergunta, sem depender apenas da semelhança temática.</p><h3>Como o rerank reordena os resultados</h3><p>Depois da busca inicial, o reranker recebe a pergunta e a lista de candidatos. Em uma única chamada, avalia cada item pela mesma rubrica, calcula o score_norm e devolve a lista em ordem decrescente de nota. <br>O fluxo é este:</p><pre>candidates = retriever.search(question, k=10)<br>ranked = reranker.rerank(question, candidates)</pre><p>Cada candidato é avaliado separadamente contra a pergunta, mas todos seguem juntos no mesmo request. A saída contém as probabilidades para os níveis 0, 1 e 2 da rubrica. Com elas, calculamos o score_norm apresentado acima e usamos esse valor para definir a nova posição de cada item.</p><pre>ranked = rerank(question, candidates, min_score=threshold)</pre><p>Os candidatos abaixo do valor definido não voltam na lista. Se nenhum passar, a aplicação pode optar por não enviar contexto ao modelo ou pedir esclarecimento. Esse corte precisa ser validado para cada domínio: ele reduz a chance de incluir contexto fraco, mas pode excluir documentos úteis. Neste experimento, usamos apenas a reordenação, sem corte.</p><p>O reranker não busca documentos novos nem altera o texto dos candidatos. Muda apenas a ordem dos itens que o retriever já encontrou. Se o primeiro resultado da busca for apenas relacionado e o terceiro realmente resolver a pergunta, o terceiro tende a subir para o topo.</p><h3>Como medimos</h3><p>Primeiro, fizemos uma validação offline com uma base de artigos de suporte, consultas escritas como clientes escreveriam e os dez primeiros resultados de uma busca vetorial, rotulados de 0 a 2. Foi nessa base que definimos a rubrica e o método de pontuação.</p><p>Na avaliação principal, usamos 100 consultas e o retriever vetorial do sistema para medir o efeito do rerank na ordem dos resultados.Foram avaliadas 100 consultas, com gabarito de relevância por documento.</p><ul><li>O baseline é a ordem original do retriever.</li><li>Com rerank: o Jev reordena os dez candidatos devolvidos pelo retriever.</li><li>Baseline e rerank usam o mesmo conjunto e o mesmo gabarito.</li><li>Recall@k é calculado nas 96 consultas que têm ao menos um relevante entre os candidatos. Nas quatro restantes, não há o que recuperar. Como o rerank apenas reordena os dez itens, Recall@10 é igual nos dois braços.</li></ul><p>O gabarito foi construído por mim com apoio de um modelo de IA, não houve segundo avaliador humano. As 100 consultas não foram usadas para ajustar a rubrica nem o score: ambos vieram da validação offline e foram aplicados sem alteração.</p><p>Nas métricas, notas 1 e 2 contam como relevantes: P@1 pergunta se o primeiro resultado é relevante, MRR mede quão cedo aparece o primeiro relevante, P@k e Recall@k contam relevantes nos primeiros k resultados. Já o nDCG@k preserva as notas 0, 1 e 2 e valoriza mais um documento que resolve a pergunta.</p><h3>Resultados: o ganho aparece no topo</h3><p>O rerank melhorou as métricas de ordenação, sobretudo onde RAG costuma ser mais sensível: o primeiro resultado e os cinco primeiros.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aZF7V-fKDOkcz5NC8cgYMA.png" /><figcaption>Antes (cinza) e depois (azul) do rerank com Jev, em 100 consultas. O ganho é maior no topo da lista.</figcaption></figure><p>O ganho não ficou restrito ao primeiro resultado. O nDCG@5 passou de 0,729 para 0,916, e o MRR foi de 0,815 para 0,935. P@3 e P@5 também subiram, de 0,703 para 0,842 e de 0,646 para 0,768. Em conjunto, as métricas mostram que os documentos relevantes passaram a aparecer mais cedo na lista.</p><p>O movimento do primeiro resultado relevante ajuda a ver como esse ganho se distribuiu pelas consultas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*TI1r4XpXa3Pug6DFt3CRzQ.png" /></figure><p>Nas 25 consultas em que a posição mudou, o primeiro relevante subiu em 21 e caiu em 4. O rerank melhorou a posição do primeiro relevante em mais de cinco vezes o número de casos em que a piorou.</p><h3>O custo: a latência precisa de contexto</h3><p>No p50, a consulta foi de 0,79 s, só com busca, para 1,74 s, com busca e rerank. A diferença ponta a ponta foi de 947 ms no p50 e 1.406 ms no p95. Isso mede o acréscimo observado naquele ambiente, não o tempo puro do modelo de rerank.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FwpcHl2d0pFZgVZesLgh0g.png" /><figcaption>Latência por etapa no p50 e no p95, medida em ambiente de validação. O total é a latência ponta a ponta medida, os percentis de cada etapa não se somam exatamente.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/1*XRHU1F7sRU5n_16BYgFV4Q.png" /></figure><p>A TypeSafe divulga latências bem menores para o Jev em seus benchmarks, mas a comparação direta não cabe aqui. Neste experimento, a chamada passou por um proxy, e a medição inclui esse caminho além do modelo. Por isso, os números são indicativos do trade-off deste pipeline no ambiente de validação, não da latência isolada do Jev nem de produção.</p><p>A lição não é adicionar um reranker a qualquer pipeline. Primeiro, vale revisar o fluxo de RAG, encontrar os gargalos e melhorar a recuperação. Só então faz sentido aplicar o rerank e medir se ele melhora o resultado final. Rerank reorganiza candidatos que já foram recuperados, ele não substitui uma busca bem formulada.</p><p>Esse custo faz sentido quando errar o primeiro documento é caro: respostas automáticas de RAG, atendimento e recomendação de um único artigo. Em autocomplete, busca enquanto a pessoa digita ou listas que o usuário explora por conta própria, a latência extra provavelmente não compensa. Enviar apenas os candidatos necessários e textos mais concisos também ajuda a reduzir esse custo.</p><h3>Limitações e próximos passos</h3><p>O resultado é promissor, mas existem alguns ponto:</p><ul><li>A amostra tem 100 consultas. Ela mostra que o rerank melhora a ordem, mas o tamanho exato do ganho pode variar com outras consultas.</li><li>O gabarito foi assistido por IA e não teve segundo avaliador humano. Isso pode favorecer um reranker que também usa modelo.</li><li>A latência foi medida em um ambiente de validação, ainda falta medi-la em condições representativas de produção.</li><li>Rubrica e score foram definidos para uma base de artigos de suporte. Outro domínio exige nova avaliação.</li></ul><p>Os próximos passos atacam essas lacunas: revisar o gabarito com um segundo avaliador humano e medir a latência em produção. Depois, comparar com um cross-encoder open source e medir o efeito na resposta final do RAG, não só na ordem dos documentos.</p><h3>Conclusão</h3><p>Reranking não corrige uma recuperação ruim. Ele resolve outro problema: quando a busca já encontra informação útil, mas não a coloca na posição que o sistema precisa.</p><p>Foi o que aconteceu aqui. O retriever trouxe candidatos relevantes, mas o rerank aumentou a chance de o primeiro resultado responder à pergunta. O próximo passo é confirmar esse ganho na resposta final, em um cenário próximo ao uso real.</p><p>O score usado no rerank carrega uma distinção útil: um resultado pode parecer relacionado e, ainda assim, não resolver a pergunta. Essa diferença ajuda a colocar no topo os candidatos com maior chance de gerar um bom contexto.</p><p>Ainda faltam comparações com outros modelos, uma avaliação humana independente e medições em produção. Mesmo assim, há uma conclusão prática: quando a recuperação já está saudável, mas a ordem dos candidatos ainda atrapalha a resposta, reranking é um dos primeiros lugares onde vale investigar.</p><h3>Referências</h3><p><a href="https://docs.typesafe.ai/models">TypeSafe: Models</a></p><p><a href="https://www.promptfoo.dev/docs/providers/typesafe/">Promptfoo: TypeSafe provider</a>: o que Score, Choice e Noul devolvem.</p><p>Nogueira e Cho, <a href="https://arxiv.org/abs/1901.04085v1">Passage Re-ranking with BERT</a> (2019): rerank com cross-encoder.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff343e851fa3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entendendo HNSW: o algoritmo por trás da busca semântica]]></title>
            <link>https://medium.com/@andre.luiz1987/entendendo-hnsw-o-algoritmo-por-tr%C3%A1s-da-busca-sem%C3%A2ntica-4a4d7732181a?source=rss-9e072dc02cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a4d7732181a</guid>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[opensearch]]></category>
            <category><![CDATA[vector-search]]></category>
            <category><![CDATA[hnsw]]></category>
            <dc:creator><![CDATA[André Coelho]]></dc:creator>
            <pubDate>Mon, 17 Aug 2026 23:52:56 GMT</pubDate>
            <atom:updated>2026-08-18T00:10:26.500Z</atom:updated>
            <content:encoded><![CDATA[<p>Eu sempre tive curiosidade de entender como a busca vetorial funciona por baixo dos panos. Uso RAG no dia a dia, mas usar não é a mesma coisa que entender o motor por trás, e quanto mais eu mexia com isso, mais eu queria saber o que realmente acontece quando você manda um vetor pra um índice e recebe os vizinhos mais próximos de volta em milissegundos, mesmo com centenas de documentos na base.</p><p>Essa curiosidade virou um estudo mais a fundo, e esse artigo é o resultado dele. Vou focar especialmente no <strong>HNSW</strong>, o algoritmo de indexação que virou padrão em bancos vetoriais. É a peça que sustenta a busca vetorial na maioria dos sistemas que a gente usa hoje, e que praticamente todo mundo configura sem saber muito bem o que tá acontecendo por baixo. Vou tentar abrir essa caixa preta.</p><h3>Da palavra-chave ao significado: por que isso importa na era do LLM</h3><p>Antes de entrar no HNSW, vale contextualizar por que busca vetorial virou um assunto tão central. Buscadores clássicos, o Elasticsearch/OpenSearch, funcionam em cima de <strong>índice invertido</strong>: pra cada palavra, uma lista de documentos que contêm aquela palavra. Funciona bem, mas é cego a significado: procurar por “carro” não traz um texto que só fala em “automóvel”, porque as letras são diferentes, mesmo a ideia sendo idêntica. É busca por correspondência de texto, não por ideia.</p><p>Isso virou um problema sério com a chegada dos LLMs e do RAG. Um modelo de linguagem não tem acesso aos seus dados privados nem ao que aconteceu depois do treinamento dele. Então, pra responder com contexto real, alguém precisa primeiro <strong>recuperar</strong> os pedaços de informação relevantes e entregar isso pro modelo dentro do prompt. E essa recuperação não pode depender de bater palavra por palavra, porque o usuário raramente pergunta com as mesmas palavras que estão no documento. É exatamente aqui que embedding e busca vetorial entram: eles permitem buscar por <strong>significado</strong>, não por <strong>forma</strong>, o que é indispensável quando quem está perguntando é uma linguagem natural solta, não uma query estruturada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vr-OheUgI0jZLajGLlZ1cw.png" /></figure><p>Isso não é só um detalhe técnico. Foi uma mudança de paradigma: se antes “buscar parecido” significava contar palavras em comum, agora significa comparar posições num espaço matemático que captura semântica. É essa virada que sustenta busca semântica, sistemas de recomendação, deduplicação e, principalmente, o retrieval por trás de todo produto sério de IA generativa.</p><h3>Por que buscar por significado é buscar por proximidade</h3><p>Computadores não operam diretamente sobre palavra, imagem ou música, eles operam sobre representações numéricas. Na prática, a forma mais comum de transformar esse conteúdo em algo comparável é usar embeddings: um modelo, geralmente uma rede neural treinada para isso, recebe um texto ou imagem e devolve uma lista de números, um vetor. <br>Esse vetor pode ser interpretado como um ponto num espaço de muitas dimensões. Um vetor de 768 números, por exemplo, corresponde a um ponto em um espaço de 768 dimensões. A gente não consegue visualizar esse espaço, mas ainda consegue medir proximidade entre pontos e usar essa proximidade como aproximação de similaridade.</p><p>O ponto central é este: embeddings representam textos, palavras ou conceitos como vetores em um espaço multidimensional. Nesse espaço, conteúdos semanticamente parecidos tendem a ficar próximos. Assim, a pergunta “quais textos são parecidos com este?” pode ser transformada em uma busca pelos pontos mais próximos, usando medidas de similaridade.</p><h3>Como medir “perto”</h3><p>Pra buscar por proximidade, precisa escolher como medir distância, e aqui tem mais de uma métrica, cada uma respondendo uma pergunta diferente:</p><ul><li><strong>Distância euclidiana (L2)</strong>: a distância em linha reta. Ela considera tanto a direção quanto a magnitude dos vetores.</li><li><strong>Similaridade de cosseno</strong>: mede o alinhamento entre dois vetores por meio do ângulo entre eles. Ela desconsidera suas magnitudes e costuma ser muito usada em embeddings de texto, pois o interesse normalmente está na semelhança semântica.</li><li><strong>Produto interno</strong>: combina direção e magnitude, e é a mais barata de calcular.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z-6YAv_Gl7VeEaxzoDQQ6A.png" /></figure><p>Essas métricas não devem ser escolhidas arbitrariamente, pois podem produzir rankings diferentes de vizinhos. No entanto, quando os vetores são normalizados, similaridade de cosseno, produto interno e distância euclidiana passam a produzir ordenações equivalentes.</p><h3>O problema real: buscar rápido numa base gigante</h3><p>Com cada dado virando um ponto, a tarefa fica bem definida: dada uma consulta, encontrar os k pontos mais próximos dela na base. É o clássico problema de <strong>k-NN</strong> (k vizinhos mais próximos), a base de recomendação, busca semântica, RAG.</p><p>A forma que nunca erra é a <strong>força bruta</strong>: calcular a distância da consulta pra cada vetor da base, ordenar, pegar os k menores. O problema é o custo. Numa base de dez milhões de vetores de 768 dimensões, uma consulta só já dá pra casa dos oito bilhões de operações. K Isso é rápido numa consulta isolada, mas em produção você tem centenas ou milhares de consultas por segundo, e o custo cresce com o produto de três coisas que só tendem a aumentar: quantidade de vetores, número de dimensões e volume de consultas. A força bruta quebra exatamente quando sua aplicação começa a fazer sucesso.</p><p>A saída é aceitar que a resposta não precisa ser perfeita. É daí que vem a <strong>busca aproximada (ANN)</strong>: estruturas que evitam olhar a base inteira, pulando direto pra vizinhança que interessa, trocando um pouco de precisão por um ganho de velocidade de ordens de magnitude.</p><p>Pra medir “quase certo” a gente usa o <strong>recall</strong>: quantos dos vizinhos verdadeiros a busca aproximada de fato trouxe.</p><p>E isso desenha o trade-off que domina a área inteira: <strong>recall, latência e memória</strong> puxando em direções opostas. Mais recall custa latência. Menos memória costuma custar recall. Configurar um índice vetorial é, no fundo, decidir onde nesse triângulo sua aplicação precisa estar. Essa mesma lógica vai reaparecer quando a gente chegar nos parâmetros do HNSW, então vale guardar essa imagem do triângulo.</p><h3>As famílias de índice</h3><p>Antes de chegar no HNSW, vale um mapa rápido das alternativas. Não fui fundo em nenhuma delas, meu estudo foi focado no HNSW mesmo, mas conhecer o básico de cada uma ajuda a entender por que o HNSW acabou virando o padrão.</p><p><strong>Flat (força bruta)</strong>: sem estrutura nenhuma, recall sempre 100%. Certo pra bases pequenas e usado como gabarito pra medir recall das outras técnicas.</p><p><strong>Árvores (KD-tree)</strong>: funcionam bem em baixa dimensão, mas quebram em alta dimensão por causa da chamada maldição da dimensionalidade. Com muitas dimensões, os pontos tendem a ficar todos a distâncias parecidas, e a poda que faz a árvore ser rápida deixa de funcionar.</p><p><strong>LSH (hashing sensível à localidade)</strong>: usa funções de hash desenhadas pra que pontos próximos caiam no mesmo balde. Funciona, mas pra atingir o mesmo recall costuma gastar mais memória e ter latência pior que grafo, então foi perdendo espaço.</p><p><strong>IVF (Inverted File)</strong>: agrupa os vetores em clusters via k-means, e na busca só varre os clusters mais próximos da consulta. Muito eficiente em memória (ainda mais combinado com compressão), mas precisa de um passo de treino antes de indexar.</p><p>E aí tem os <strong>grafos navegáveis</strong>, onde mora o HNSW.</p><h3>HNSW: quem criou e de onde veio a ideia</h3><p>O HNSW, Hierarchical Navigable Small World, foi criado por Yury Malkov e Dmitry Yashunin, publicado primeiro como preprint em 2016 e depois formalizado num paper de 2018. O HNSW também não surgiu do nada: Malkov já tinha trabalhado no NSW, a versão sem hierarquia, em papers anteriores, de 2011 e 2014, antes de chegar na versão com camadas junto com Yashunin. Pra montar essa versão com camadas, os dois juntaram duas ideias emprestadas de áreas bem diferentes.</p><h4>De onde vem o mundo pequeno</h4><p>Existe uma teoria conhecida como “seis graus de separação”: a ideia de que duas pessoas quaisquer estão ligadas por uma cadeia curta de conhecidos. Isso não é só senso comum. Em 1967 o psicólogo Stanley Milgram testou isso na prática, pedindo pra moradores de Nebraska e Kansas fazerem uma carta chegar até um desconhecido em Boston, passando de mão em mão só entre pessoas que se conheciam pelo primeiro nome. As cartas que chegaram levaram, em média, algo perto de seis intermediários, um número pequeno pra uma população de milhões.</p><p>Décadas depois, os pesquisadores Watts e Strogatz explicaram matematicamente por que isso acontece, e a explicação não é que cada pessoa seja especial. É a estrutura da rede: a maioria das suas conexões é local, mas você tem algumas poucas conexões de longo alcance (aquele parente que morou fora, um colega de intercâmbio) que funcionam como atalho. É essa combinação de muita conexão local com poucas pontes longas que dá origem ao <strong>mundo pequeno</strong>.</p><h4>Como isso aparece no NSW</h4><p>O NSW (Navigable Small World) aplica a ideia de um mundo pequeno navegável a um grafo de objetos. Cada objeto, como um vetor, é representado por um nó. As arestas conectam objetos considerados próximos, enquanto algumas conexões de maior alcance também são preservadas durante a construção do grafo.</p><p>Essas conexões cumprem papéis diferentes. As conexões curtas permitem refinar a busca em uma região do espaço. As conexões longas permitem atravessar rapidamente regiões distantes, evitando que a busca precise avançar apenas por pequenos passos.</p><p>Em sua forma mais simples, a busca é gulosa. Ela começa em um nó de entrada, compara a consulta com os vizinhos desse nó e avança para aquele que estiver mais próximo da consulta. O processo se repete até chegar a um nó que não possua nenhum vizinho melhor.</p><p>O problema é que esse ponto pode ser apenas um mínimo local: ele é melhor do que todos os seus vizinhos imediatos, mas não é necessariamente o verdadeiro vizinho mais próximo da consulta. O NSW utiliza estratégias adicionais para melhorar a probabilidade de encontrar bons resultados, mas sua organização em uma única camada mistura conexões de diferentes escalas.</p><h4>De onde vem a hierarquia</h4><p>Precisava de alguma coisa que desse pra busca uma visão de cima antes de mergulhar no grafo, em vez de começar de um ponto qualquer e torcer pra não ficar presa num mínimo local. Malkov foi buscar essa peça numa estrutura de dados clássica, que resolve um problema parecido em outro contexto: a <strong>skip list</strong>.</p><p>Uma skip list acelera buscas em uma sequência ordenada criando vários níveis. O nível inferior contém todos os elementos. Cada nível superior contém um subconjunto progressivamente menor, permitindo saltos maiores. A busca começa no nível mais alto, avança em passos largos e desce gradualmente para níveis mais detalhados.</p><p>O HNSW faz isso com o grafo do NSW: empilha ele em camadas. A camada 0, na base, tem todos os nós, densamente conectados. Cada camada acima tem um subconjunto cada vez menor, com conexões mais longas. No topo sobra pouquíssimo nó, com pontes bem largas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/528/1*XYwk3dXI-rJ_ZShqjWJAjA.png" /></figure><h4>Como o grafo é montado</h4><p>Cada vetor novo passa por três etapas na inserção: sorteia a própria camada máxima, desce do topo até uma camada acima da sua, fazendo uma busca gulosa simples só pra se posicionar (sem criar conexão ainda), e daí pra baixo, camada por camada, faz uma busca mais ampla pra achar bons candidatos e se conecta a alguns deles.</p><p>O detalhe que faz o grafo ser bom ou ruim é como escolher esses vizinhos. Pegar simplesmente os mais próximos parece óbvio, mas eles tendem a estar todos amontoados na mesma direção, e aí você cria um beco sem saída pra navegação. O HNSW usa uma heurística que prioriza diversidade: só aceita um candidato se ele estiver mais perto do novo nó do que de qualquer vizinho já escolhido. Isso espalha as conexões em direções diferentes, preservando as pontes longas que fazem o mundo pequeno funcionar.</p><h4>Como a busca funciona</h4><p>A busca tem duas fases bem diferentes. Na primeira, ela desce pelas camadas superiores navegando de forma gulosa, até chegar na base. Na segunda, já na camada 0, ela passa a manter uma lista de candidatos, explorando vizinhos e atualizando essa lista, com um critério de parada bem definido: se o próximo candidato a explorar já está mais longe do que o pior resultado guardado, não vale a pena continuar.</p><p>Essa lista de candidatos da camada 0 é controlada por um parâmetro, e é ele que abre a porta pra próxima parte: como calibrar o HNSW na prática.</p><h4>Os três parâmetros que você realmente mexe</h4><p>Na prática, o que você opera são três botões, e nenhum deles é bom ou ruim isolado. Cada um compra uma coisa e cobra outra.</p><p><strong>m</strong> controla quantas conexões cada nó mantém no grafo. Mais conexão melhora recall e robustez, mas custa memória diretamente, porque entra na fórmula de tamanho do índice.</p><p><strong>ef_construction</strong> controla o esforço da busca durante a construção do grafo. Ele não define quantos vizinhos cada nó terá, mas quantos candidatos o algoritmo avalia ao procurar os melhores vizinhos possíveis para uma nova conexão. Quanto maior esse valor, maior tende a ser a qualidade do grafo, mas mais lenta fica a indexação. Esse custo é pago durante a construção ou atualização do índice e pode beneficiar todas as buscas futuras.</p><p><strong>ef_search</strong> controla o esforço da busca em tempo real, e é exatamente a lista de candidatos da camada 0 que mencionei acima. É o único que você ajusta consulta a consulta, sem reconstruir nada, a alavanca que você mexe em produção pra equilibrar recall e latência conforme a necessidade do momento. Quanto maior, mais a busca explora antes de parar, o que melhora o recall e custa mais tempo.</p><h3>Na prática: HNSW no OpenSearch</h3><p>Até aqui foi tudo algoritmo. Rodar isso de verdade envolve outras coisas: onde guardar os vetores, como escalar pra mais de uma máquina, como juntar isso com filtro de metadado. Vou mostrar essa parte no <strong>OpenSearch</strong>, que é o que eu uso nos meus projetos, e é ali que m, ef_construction e ef_search viram configuração de verdade. A lógica é a mesma em outros bancos vetoriais, tipo Qdrant, Weaviate e Milvus, só muda o nome dos parâmetros.</p><p>Configurar isso no OpenSearch envolve duas decisões separadas. A primeira é qual algoritmo de indexação usar, isso é o <strong>method</strong>, e as opções são hnsw ou ivf (os mesmos que a gente já viu ao longo do artigo). A segunda é qual biblioteca vai efetivamente executar esse algoritmo por baixo dos panos, isso é o <strong>engine</strong>, e as opções são faiss, lucene ou nmslib (essa última já descontinuada). O HNSW é a receita, as engines são cozinheiros diferentes seguindo a mesma receita, cada uma com suas formas de armazenamento, memória e filtragem.</p><p>O mapeamento de um campo vetorial junta tudo o que a gente viu até aqui:</p><pre>PUT /busca-semantica<br>{<br>  &quot;settings&quot;: {<br>    &quot;index&quot;: {<br>      &quot;knn&quot;: true,<br>      &quot;knn.algo_param.ef_search&quot;: 100<br>    }<br>  },<br>  &quot;mappings&quot;: {<br>    &quot;properties&quot;: {<br>      &quot;embedding&quot;: {<br>        &quot;type&quot;: &quot;knn_vector&quot;,<br>        &quot;dimension&quot;: 768,<br>        &quot;space_type&quot;: &quot;cosinesimil&quot;,<br>        &quot;method&quot;: {<br>          &quot;name&quot;: &quot;hnsw&quot;,<br>          &quot;engine&quot;: &quot;faiss&quot;,<br>          &quot;parameters&quot;: {<br>            &quot;ef_construction&quot;: 100,<br>            &quot;m&quot;: 16<br>          }<br>        }<br>      }<br>    }<br>  }<br>}</pre><p>Repara nos valores escolhidos pra m, ef_construction e ef_search: não são números aleatórios, são os defaults reais do OpenSearch pro method HNSW, e batem com os padrões que já vimos lá em &quot;Os três parâmetros que você realmente mexe&quot;. m = 16 é o default e também o valor mais usado como ponto de partida em outros sistemas, equilibra recall e memória sem exagerar em nenhum dos dois. ef_construction = 100 também é o default, suficiente pra montar um grafo de qualidade razoável sem deixar a indexação muito lenta (se você quiser um grafo melhor e não se importar de esperar mais na indexação, vale subir esse valor). E ef_search = 100, que aparece nas configurações do índice, é um valor conservador pra começar a testar, alto o bastante pra dar um recall razoável, mas pensado pra ser ajustado depois que você medir o resultado real na sua base (é exatamente isso que a seção sobre calibrar ef_search, mais adiante, mostra como fazer).</p><p>Dois pontos merecem atenção aqui. Primeiro, &quot;knn&quot;: true liga o mecanismo de busca vetorial pro índice, e esquecer isso é o erro número um de quem tá começando. Segundo, o space_type precisa bater com a métrica que o modelo de embedding usa: se você usar a métrica errada, não dá erro nenhum, só piora os resultados silenciosamente, o que é bem mais chato de debugar.</p><p>Uma busca típica pede os k vizinhos mais próximos:</p><pre>GET /busca-semantica/_search<br>{<br>  &quot;size&quot;: 5,<br>  &quot;query&quot;: {<br>    &quot;knn&quot;: {<br>      &quot;embedding&quot;: { &quot;vector&quot;: [0.20, -0.01, 0.77, &quot;...&quot;], &quot;k&quot;: 5 }<br>    }<br>  }<br>}</pre><p>E dá pra embutir filtro de metadado direto na busca vetorial, o que resolve um problema real: buscar “os mais parecidos, mas só na categoria X” sem perder a vantagem do índice.</p><pre>&quot;knn&quot;: {<br>  &quot;embedding&quot;: {<br>    &quot;vector&quot;: [0.20, -0.01, 0.77, &quot;...&quot;],<br>    &quot;k&quot;: 5,<br>    &quot;filter&quot;: { &quot;term&quot;: { &quot;categoria&quot;: &quot;esportes&quot; } }<br>  }<br>}</pre><p>Engines como FAISS e Lucene aplicam esse filtro durante a travessia do grafo, não depois. Isso importa porque um pós-filtro ingênuo (busca primeiro, filtra depois) pode jogar fora quase tudo se o filtro for restritivo, e um pré-filtro ingênuo (filtra primeiro, busca depois) perde a vantagem do índice se o subconjunto for grande. As engines decidem dinamicamente qual estratégia usar conforme a seletividade do filtro.</p><p>Como o ef_search é ajustável, dá pra sentir esse efeito na prática sem reconstruir nada, desde que você passe o valor por consulta, dentro da própria query:</p><pre>GET /busca-semantica/_search<br>{<br>  &quot;size&quot;: 10,<br>  &quot;query&quot;: {<br>    &quot;knn&quot;: {<br>      &quot;embedding&quot;: {<br>        &quot;vector&quot;: [0.20, -0.01, 0.77, ...],<br>        &quot;k&quot;: 10,<br>        &quot;method_parameters&quot;: { &quot;ef_search&quot;: 300 }<br>      }<br>    }<br>  }<br>}</pre><p>Eu criei uma base a partir do dataset AG News pra demonstrar isso na prática: 20 mil notícias do dataset AG News, processadas por um modelo de sentence embeddings (all-MiniLM-L6-v2, 384 dimensões), com m=16 e ef_construction=128 fixos, medindo sempre contra o gabarito da força bruta (a distância exata, calculada sobre os mesmos vetores indexados) enquanto variei o ef_search de 10 até 512.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*n_9rqRlilK0hrWJ3i7mq6Q.png" /></figure><p>O padrão bate com a teoria: quanto maior o ef_search, mais recall, mas com ganho cada vez menor perto do topo. A latência sobe de forma suave e consistente, sem saltos bruscos. É o trade-off que a gente vem discutindo desde o começo do artigo, agora com números de verdade.</p><h3>Conclusão</h3><p>Era isso que eu queria entender quando comecei a puxar esse fio: o que acontece entre o momento em que você manda um vetor para o índice e o momento em que os vizinhos mais próximos voltam rápido, mesmo com bases grandes. Em muitos sistemas modernos, uma parte importante dessa resposta é o HNSW: um grafo em camadas que encurta o caminho até os vizinhos mais prováveis.</p><p>Não existe configuração ideal universal aqui, existe trade-off. Cada escolha, da métrica de distância aos parâmetros do índice, desloca o ponto de equilíbrio entre recall, latência e memória. Entender isso muda a forma de configurar busca vetorial: em vez de copiar valores da documentação, você passa a escolher sabendo o que está ganhando e o que está abrindo mão.</p><h3>Referencias</h3><ul><li>Malkov, Y. A.; Yashunin, D. A. “Efficient and Robust Approximate Nearest Neighbor Search Using Hierarchical Navigable Small World Graphs” (IEEE TPAMI, 2018). <a href="https://dl.acm.org/doi/10.1109/tpami.2018.2889473">dl.acm.org</a>, disponível em <a href="https://arxiv.org/abs/1603.09320">arXiv:1603.09320</a></li><li>Ramoliya, K. “Understanding HNSW, Hierarchical Navigable Small World”. <a href="https://keyurramoliya.com/posts/Understading-HNSW-Hierarchical-Navigable-Small-World/">keyurramoliya.com</a></li><li>Verma, N.; Nakkirtha, V. V. “Efficient filtering in OpenSearch vector engine”. <a href="https://opensearch.org/blog/efficient-filters-in-knn/">OpenSearch Blog</a></li><li>“Efficient k-NN filtering”. <a href="https://docs.opensearch.org/latest/vector-search/filter-search-knn/efficient-knn-filtering/">OpenSearch Documentation</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a4d7732181a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mem0 + OpenSearch: memória para agentes que dá continuidade de verdade]]></title>
            <link>https://medium.com/@andre.luiz1987/mem0-opensearch-mem%C3%B3ria-para-agentes-que-d%C3%A1-continuidade-de-verdade-60cd9ff113ca?source=rss-9e072dc02cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/60cd9ff113ca</guid>
            <category><![CDATA[opensearch]]></category>
            <category><![CDATA[mem0]]></category>
            <category><![CDATA[semantic-search]]></category>
            <category><![CDATA[agent-memory]]></category>
            <dc:creator><![CDATA[André Coelho]]></dc:creator>
            <pubDate>Sun, 22 Feb 2026 19:05:35 GMT</pubDate>
            <atom:updated>2026-02-22T22:20:13.192Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LN9Hx_zfYTmNi7sj7gAfpg.png" /></figure><p>Quando a gente constrói assistentes e agentes, o maior salto de qualidade acontece quando eles deixam de ser só “bons em responder” e passam a ser bons em continuar. Sem memória, cada interação vira um recomeço: o usuário repete preferências, retoma contexto, explica de novo o que já explicou ontem e, no meio do caminho, o agente faz perguntas óbvias ou oferece sugestões fora de hora. No fim, isso vira fricção e quebra a sensação de continuidade.</p><p>Só que guardar memória não significa salvar tudo. A ideia é capturar sinais úteis com intenção e conseguir trazer isso de volta quando realmente ajuda. Se o agente consegue recuperar um fato relevante na hora certa, ele responde melhor e a conversa flui sem o usuário precisar recontar a história.</p><p>É nesse ponto que o <strong>Mem0</strong> entra como uma camada de memória para aplicações de IA. Ele ajuda seu sistema a transformar interações em memórias consultáveis e recuperar essas memórias depois, quando o agente precisa de contexto. Na prática, você ganha um fluxo bem direto: salvar memórias com os identificadores corretos (como usuário e agente) e buscar com linguagem natural, usando busca semântica e filtros.</p><p>Neste artigo eu vou mostrar o Mem0 rodando self hosted, usando o OpenSearch como base vetorial. A ideia é ir no que importa pra começar: configurar, salvar algumas memórias, inspecionar como isso aparece no OpenSearch e depois recuperar esses dados explorando score, threshold e filtros por metadados.</p><h3>Mem0 self hosted: por que vamos por esse caminho</h3><p>O Mem0 pode ser usado como plataforma gerenciada ou rodando na sua própria infraestrutura. Aqui vamos seguir com self hosted porque ele deixa tudo mais transparente: você controla onde os dados ficam, como o índice é estruturado, qual o mapping, como funciona retenção e como a consulta acontece de verdade. O trade off é assumir a parte operacional, mas para um cenário de engenharia e aprendizado isso é exatamente o que a gente quer.</p><h3>Pré requisitos e stack</h3><p>Para os exemplos, vamos usar Python para codificação e OpenSearch como vector store. Também vou rodar tudo local com Docker, porque facilita repetir o passo a passo e inspecionar os dados indexados sem depender de ambiente externo.</p><h3>Instalando e criando a instância de memória</h3><p>Em um projeto Python, primeiro instalamos a lib:</p><pre>pip install mem0ai</pre><p>Depois, criamos o objeto de configuração. Ele é o coração do setup porque define três coisas: qual LLM o Mem0 usa quando precisa “inferir” memórias, qual embedder gera os vetores, e onde esses vetores vão ser persistidos.</p><pre>config = {<br>    &quot;llm&quot;: {<br>        &quot;provider&quot;: &quot;openai&quot;,<br>        &quot;config&quot;: {<br>            &quot;model&quot;: &quot;gpt-4.1-nano-2025-04-14&quot;,<br>            &quot;temperature&quot;: 0.2,<br>            &quot;max_tokens&quot;: 2000,<br>        }<br>    },<br>    &quot;embedder&quot;: {<br>        &quot;provider&quot;: &quot;openai&quot;,<br>        &quot;config&quot;: {<br>            &quot;api_key&quot;: os.getenv(&quot;OPENAI_API_KEY&quot;),<br>            &quot;model&quot;: &quot;text-embedding-3-small&quot;,<br>        },<br>    },<br>    &quot;vector_store&quot;: {<br>        &quot;provider&quot;: &quot;opensearch&quot;,<br>        &quot;config&quot;: {<br>            &quot;collection_name&quot;: &quot;mem0&quot;,<br>            &quot;host&quot;: &quot;localhost&quot;,<br>            &quot;port&quot;: 9200,<br>            &quot;embedding_model_dims&quot;: 1536,<br>            &quot;pool_maxsize&quot;: 20,<br>            &quot;use_ssl&quot;: False,<br>            &quot;verify_certs&quot;: False,<br>        },<br>    },<br>}<br><br>m = Memory.from_config(config)</pre><p>Alguns pontos que valem atenção aqui:</p><p>No bloco llm, você define qual provedor e qual modelo serão usados quando o Mem0 precisar transformar o texto original em uma “memória” mais limpa e objetiva. Isso entra em cena principalmente quando você usa infer=True. Para saber sobre outro provedores suportados clique no link a seguir: <a href="https://docs.mem0.ai/components/llms/config">https://docs.mem0.ai/components/llms/config</a></p><p>No bloco embedder, você define como o embedding será gerado. Aqui eu usei um modelo com dimensão 1536, e isso precisa casar com o que o índice do OpenSearch espera. Veja no link os embedders suportados: <a href="https://docs.mem0.ai/components/embedders/overview">https://docs.mem0.ai/components/embedders/overview</a></p><p>No bloco vector_store, você define o OpenSearch como destino. O campo embedding_model_dims é crítico: se o índice do OpenSearch estiver com dimensão diferente no campo vetorial, a indexação vai falhar. Existem outras opções de bases que podem serem consultadas aqui: <a href="https://docs.mem0.ai/components/vectordbs/overview">https://docs.mem0.ai/components/vectordbs/overview</a></p><h3>Separando memórias por usuário, agente e execução</h3><p>Uma coisa que ajuda muito quando você está rodando isso em produção é separar as memórias por contexto de uso. Na prática, isso significa sempre gravar e buscar com os identificadores certos, para não misturar memória de pessoas diferentes, agentes diferentes ou execuções diferentes.</p><p>Você vai ver isso nos exemplos usando user_id e agent_id. Em cenários mais avançados, também faz sentido usar app_id e run_id quando você quer rastrear uma jornada específica ou uma sessão.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l0ngRC5JSdW4rjsrN9RJ3g.png" /><figcaption>Source: <a href="https://docs.mem0.ai/platform/features/entity-scoped-memory#feature-anatomy">https://docs.mem0.ai/platform/features/entity-scoped-memory#feature-anatomy</a></figcaption></figure><h3>Salvando memórias</h3><p>Agora vamos registrar duas memórias simples, usando metadata para categorizar:</p><pre>m.add(&quot;Na Segunda feira assisti Avatar 3&quot;,<br>      user_id=&quot;Fulano&quot;,<br>      agent_id=&quot;agent_xpto&quot;,<br>      metadata={&quot;category&quot;: &quot;movies&quot;, &quot;genre&quot;: &quot;fantasy&quot;},<br>      infer=True)<br><br>m.add(&quot;Na Sexta feira assisti Guerra dos mundos&quot;,<br>      user_id=&quot;Fulano&quot;,<br>      agent_id=&quot;agent_xpto&quot;,<br>      metadata={&quot;category&quot;: &quot;movies&quot;, &quot;genre&quot;: &quot;fiction&quot;},<br>      infer=True)</pre><p>Repara no infer=True. Quando você liga isso, o Mem0 pode pedir para o LLM reescrever o conteúdo como uma memória mais direta, limpa e consistente. Isso costuma melhorar a recuperação depois, porque o texto armazenado fica mais “factual” e menos parecido com um pedaço de conversa.</p><p>Se a sua intenção for armazenar exatamente a frase original, você pode usar infer=False.</p><h3>Inspecionando no OpenSearch: o que foi indexado</h3><p>Depois de salvar, vale olhar no OpenSearch para entender o que realmente foi para o índice. Aqui entra a parte legal do self hosted: dá para ver exatamente o documento persistido.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xxEfvs7H85JOlH7QT9mwxA.png" /></figure><p>O Mem0 cria um campo para o vetor, ovector_field (o nome exato depende do provider/config). Já os metadados entram dentro de um objeto, o payload, onde ficam category e genre.</p><p>Outro detalhe importante: o texto armazenado pode não ser exatamente o texto original. Por exemplo, você pode ver algo como:</p><p>&quot;data&quot;: &quot;Assistiu ao final de Guerra dos Mundos na sexta-feira&quot;</p><p>Isso acontece justamente por causa do infer=True, porque o Mem0 pediu para o LLM transformar a frase em uma memória mais “organizada”.</p><h3>Buscando memória: semântica, score e threshold</h3><p>Agora vem a parte que faz isso valer a pena: a busca semântica. Em vez de depender de keyword, você consegue perguntar de forma natural e recuperar o que faz sentido pelo significado.</p><pre>results = m.search(&quot;O qual filme assisti na segunda feita?&quot;, user_id=&quot;Fulano&quot;)</pre><p>O retorno traz a memória mais relevante e um score. Esse score é útil para você controlar qualidade de resposta, especialmente quando você não quer que o agente “invente continuidade” com uma memória fraca.</p><pre>{<br>  &quot;results&quot;: [<br>    {<br>      &quot;id&quot;: &quot;164ed4c3-9f49-4435-9513-afea31a4908f&quot;,<br>      &quot;memory&quot;: &quot;Assistiu Avatar 3 na segunda-feira&quot;,<br>      &quot;hash&quot;: &quot;8ca9fad6a3754dca615d93c19c825c29&quot;,<br>      &quot;metadata&quot;: {<br>        &quot;category&quot;: &quot;movies&quot;,<br>        &quot;genre&quot;: &quot;fantasy&quot;<br>      },<br>      &quot;score&quot;: 0.69596535,<br>      &quot;created_at&quot;: &quot;2026-02-22T10:21:24.919056-08:00&quot;,<br>      &quot;updated_at&quot;: null,<br>      &quot;user_id&quot;: &quot;Fulano&quot;,<br>      &quot;agent_id&quot;: &quot;agent_xpto&quot;<br>    }<br>  ]<br>}</pre><p>Se você quiser cortar resultados abaixo de um certo nível, dá para usar threshold. E se quiser restringir por metadata, dá para usar filters:</p><pre>results = m.search(&quot;O qual filme assisti na segunda feita?&quot;,<br>                   user_id=&quot;Fulano&quot;,<br>                   threshold=0.69,<br>                   filters={&quot;genre&quot;: &quot;fantasy&quot;})</pre><p>Aqui a ideia é simples: você continua usando semântica para achar o que combina, mas evita trazer coisas fora do recorte que você quer.</p><h3>Conclusão</h3><p>A base do Mem0 é essa: você salva memórias com contexto (ids e metadata), ele indexa isso em um vector store como o OpenSearch, e depois você recupera com busca semântica. Com pouco código, você já consegue sair do “assistente que recomeça sempre” para algo que mantém continuidade e toma decisões melhores porque tem contexto.</p><p>Daqui, os próximos passos naturais são evoluir regras de retenção, trabalhar melhor o que vira memória e montar proteções para não repetir memórias ou sugerir coisas fora de hora.</p><h3>Referências</h3><ul><li><a href="https://docs.mem0.ai/open-source/overview">Overview - Mem0</a></li><li><a href="https://github.com/mem0ai/mem0">GitHub - mem0ai/mem0: Universal memory layer for AI Agents</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60cd9ff113ca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Extração de Boletos: uma comparação prática entre GPT e AWS Textract]]></title>
            <link>https://medium.com/inside-picpay/extra%C3%A7%C3%A3o-de-boletos-uma-compara%C3%A7%C3%A3o-pr%C3%A1tica-entre-gpt-e-aws-textract-a94472dc96dc?source=rss-9e072dc02cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/a94472dc96dc</guid>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[picpay]]></category>
            <category><![CDATA[aws-textract]]></category>
            <category><![CDATA[gpt]]></category>
            <category><![CDATA[ocr]]></category>
            <dc:creator><![CDATA[André Coelho]]></dc:creator>
            <pubDate>Tue, 20 Jan 2026 18:55:58 GMT</pubDate>
            <atom:updated>2026-02-23T18:17:48.991Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aGg83sZUpCURyDmQqaKdqA.png" /></figure><p><em>Antes de tudo, este texto não tem como objetivo dizer qual tecnologia é melhor ou pior. O que compartilho aqui são impressões práticas obtidas a partir do uso real dessas soluções em um cenário específico, com seus acertos e limitações.</em></p><p>Em sistemas de pagamento, especialmente aqueles que lidam com boletos bancários em PDF, é comum a necessidade de aplicar OCR para identificar informações essenciais que permitem concluir uma transação. Entre esses dados, um é crítico: a linha digitável do boleto, a representação numérica do código de barras.<br>Sem a extração correta dessas informações, o pagamento simplesmente não acontece.</p><h3>O que é OCR e por que ele é essencial nesse cenário</h3><p>OCR, ou Optical Character Recognition, é a técnica usada para extrair texto a partir de imagens ou documentos escaneados. No contexto de boletos, isso significa transformar um PDF que, na prática, é apenas uma imagem, em texto estruturado que o sistema consegue interpretar.</p><p>O objetivo aqui é além de extrair todo o conteúdo do documento, identificar com precisão campos específicos que fazem parte do fluxo de pagamento.</p><h3>Tecnologias avaliadas</h3><p>Nesta análise, comparei duas abordagens diferentes para OCR.</p><p>A primeira usando o modelo multimodal GPT-4o, que combina visão computacional com compreensão de linguagem natural.</p><p>A segunda usando o serviço AWS Textract, um OCR especializado em extração de texto de documentos.</p><h3>Metodologia dos testes</h3><p>Os testes foram realizados com 18 boletos em PDF, provenientes de diferentes empresas e concessionárias. Todos os testes foram executados via scripts em Python.</p><p>O foco da análise foi restrito a identificação da linha digitável. Outros campos do boleto não foram considerados relevantes para este cenário.</p><p>Além da qualidade da extração, medi também o tempo médio necessário para processar cada documento.</p><h3>OCR usando GPT</h3><p>Para este teste usei o modelo GPT-4o, principalmente por ser um modelo multimodal com suporte nativo a visão, o que permite enviar a imagem do boleto diretamente e pedir a extração do texto no mesmo fluxo.</p><p>No caso do GPT, um script em Python foi criado com um prompt orientando o modelo a agir como um OCR, solicitando explicitamente a extração fiel do texto presente na imagem do boleto.</p><p><strong>Resultados gerais:<br></strong>- 18 arquivos processados<br>- Tempo total aproximado de 458 segundos<br>- Tempo médio por arquivo de cerca de 25 segundos</p><p><strong>Em termos de tokens, a média ficou em torno de:<br></strong>- 1180 tokens de entrada<br>- 855 tokens de saída<br>- 2035 tokens totais</p><p>Ao analisar arquivo por arquivo, foi possível observar que, quando o GPT realizava a extração, a linha digitável estava corretos. No entanto, alguns documentos falharam completamente, retornando pouquíssimo texto ou praticamente nada.</p><p>Outro ponto relevante é a grande variação no tempo de processamento entre os arquivos, o que dificulta previsibilidade em sistemas que exigem baixa latência.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q4chmC34qbg-qZhZfbQvSQ.png" /></figure><p>Esses casos chamam atenção porque o tempo de execução foi muito baixo, indicando que o modelo possivelmente não conseguiu interpretar corretamente a imagem ou o layout do documento.</p><h3>OCR usando AWS Textract</h3><p>A utilização do Textract exige um pouco mais de trabalho inicial, principalmente na configuração de credenciais, permissões e políticas na AWS.</p><p>Após essa etapa, foi criado um script em Python responsável por enviar os arquivos através da API Detect Document Text e recebe o texto extraído.</p><p><strong>Resultados gerais<br>- </strong>18 arquivos processados<br>- Tempo total de aproximadamente 83 segundos<br>- Tempo médio por arquivo de cerca de 4,6 segundos</p><p>Em todos os arquivos, o texto foi extraído corretamente. O campo de interesse, linha digitável, estavam consistentes com o conteúdo original do PDF.</p><p>O gráfico abaixo mostra o tempo por arquivo, e dá para ver que a variação é bem menor do que no GPT, com os PDFs ficando em uma faixa bem mais estável.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vU7Gd3bZK62BbCNyx01tQQ.png" /></figure><p>Comparado ao GPT, o Textract apresentou um tempo de execução significativamente menor e uma consistência muito maior entre os documentos. Nesse conjunto de testes, o Textract ficou bem próximo da média, enquanto no GPT ele passou de 41s, reforçando a diferença de previsibilidade.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XrhGF3joXfEMAoWQ7gce1Q.png" /></figure><h3>Custos</h3><p>No caso do GPT, o custo está diretamente ligado ao uso de tokens. Considerando a média de aproximadamente 2000 tokens por documento, o custo pode variar bastante dependendo do modelo e da escala do sistema.</p><p>Já o Textract possui uma precificação mais previsível. No teste foi utilizada a API Detect Document Text, cujo custo, segundo a documentação oficial da AWS, é cobrado por volume de páginas processadas.</p><p>Até um milhão de páginas por mês, o valor é de USD 1,50 por mil páginas. Acima disso, o valor cai para USD 0,60 por mil páginas.</p><h3>Conclusão</h3><p>A partir dos resultados, fica claro que ambas as abordagens funcionam, mas atendem a necessidades diferentes.</p><p>O GPT mostrou que consegue realizar OCR e extrair corretamente os dados quando o processamento acontece como esperado. Além disso, ele traz a vantagem de entender contexto, o que pode ser útil em cenários mais complexos no futuro. No entanto, apresentou falhas em alguns documentos e um tempo de execução mais alto e instável.</p><p>O AWS Textract, por outro lado, se mostrou extremamente consistente e rápido para o objetivo proposto. Para um sistema de pagamento que exige previsibilidade, baixa latência e extração confiável de campos bem definidos, ele se encaixa de forma mais natural.</p><p>No fim, a escolha não é sobre qual tecnologia é melhor, mas sim sobre qual problema você está tentando resolver.</p><h3>Referências</h3><p><strong>AWS Textract</strong><br> <a href="https://aws.amazon.com/pt/textract/">https://aws.amazon.com/pt/textract/</a></p><p><strong>GPT-4o</strong><br> <a href="https://platform.openai.com/docs/models/gpt-4o">https://platform.openai.com/docs/models/gpt-4o</a></p><p><strong>Pricing OpenAI</strong><br> <a href="https://platform.openai.com/docs/pricing">https://platform.openai.com/docs/pricing</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a94472dc96dc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/inside-picpay/extra%C3%A7%C3%A3o-de-boletos-uma-compara%C3%A7%C3%A3o-pr%C3%A1tica-entre-gpt-e-aws-textract-a94472dc96dc">Extração de Boletos: uma comparação prática entre GPT e AWS Textract</a> was originally published in <a href="https://medium.com/inside-picpay">Inside PicPay</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Muito além do LLM: porque RAG importa e como funciona]]></title>
            <link>https://medium.com/inside-picpay/muito-al%C3%A9m-do-llm-porque-rag-importa-e-como-funciona-059bb3b16736?source=rss-9e072dc02cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/059bb3b16736</guid>
            <category><![CDATA[picpay]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[André Coelho]]></dc:creator>
            <pubDate>Wed, 02 Apr 2025 23:24:22 GMT</pubDate>
            <atom:updated>2025-04-04T15:40:55.566Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KvAuJQ8XdlpJSm4gMTt8AA.png" /></figure><p>Nos últimos anos, modelos de linguagem de grande escala (LLMs) transformaram a forma como interagimos com conteúdo em linguagem natural. No entanto, esses modelos são treinados com grandes volumes de dados gerais disponíveis na internet, o que limita sua capacidade de responder com precisão em contextos específicos.</p><p>O <strong>Retrieval-Augmented Generation (RAG)</strong> surge como uma resposta a essa limitação. Ao combinar mecanismos de busca com geração de texto, o RAG permite que modelos acessem conteúdos externos e atualizados. Essa abordagem melhora a precisão das respostas, reduz a alucinação e amplia a aplicação dos LLMs para cenários corporativos, técnicos e personalizados.</p><p>Este artigo apresenta os principais componentes de uma arquitetura RAG, suas motivações e desafios típicos de implementação.</p><h3>Por que usar RAG?</h3><p>Apesar do avanço dos modelos de linguagem, ainda podem existir limites importantes, principalmente quando o conhecimento necessário vai além do que foi aprendido durante o treinamento. Isso acontece com frequência em situações que envolvem informações internas, conteúdo sensível ao tempo ou domínios específicos, onde o modelo não tem acesso direto às fontes de dados.</p><p>Nesses casos, confiar apenas no que o modelo “sabe” pode resultar em respostas incompletas, genéricas ou até incorretas.</p><p>É nesse contexto que o <strong>Retrieval-Augmented Generation (RAG)</strong> se destaca. Ele oferece uma solução que separa o modelo da fonte de conhecimento, permitindo que o sistema recupere trechos relevantes de uma base atualizada e use essas informações como contexto para gerar uma resposta. Essa separação traz vantagens como:</p><ul><li><strong>Atualização contínua</strong>: o conteúdo pode ser modificado a qualquer momento.</li><li><strong>Transparência</strong>: é possível saber quais documentos embasaram uma resposta.</li><li><strong>Redução de alucinações</strong>: o modelo passa a operar com contexto mais preciso e ancorado em fatos.</li></ul><p>Essa separação também torna o sistema mais modular, permitindo aplicar o mesmo mecanismo em diferentes domínios ou casos de uso, sem precisar modificar sua estrutura base.</p><h3>Arquitetura básica do RAG</h3><p>A arquitetura RAG combina dois processos: <strong>recuperar informações relevantes</strong> de uma base de conhecimento e <strong>gerar uma resposta</strong> com base nesse conteúdo. A ideia é ampliar a capacidade do modelo com dados externos, específicos e atualizados.</p><h4>Etapa 1: Ingestão e indexação dos dados</h4><p>O primeiro passo é garantir que o dados esteja acessível ao sistema. Isso começa pela ingestão de documentos que podem vir de fontes variadas como artigos, FAQs, bases internas, arquivos PDF ou páginas web.</p><p>Esses documentos passam por uma etapa de pré-processamento, onde são segmentados em trechos menores (<em>chunks</em>), normalmente por tamanho ou estrutura lógica (ex: parágrafos ou seções). Essa divisão é importante para melhorar a precisão da recuperação e evitar o envio de conteúdo irrelevante ao modelo.</p><p>Cada trecho é então transformado em um vetor numérico por um modelo de embedding. Esses vetores, junto com metadados úteis (como título, origem ou tags), são armazenados em um índice vetorial, que permite buscas por similaridade vetorial.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6CreL8l0Ohnrj8O7" /><figcaption><em>Fluxo da ingestão até a criação do índice vetorial.</em></figcaption></figure><h4>Etapa 2: Consulta e geração da resposta</h4><p>Quando um usuário faz uma pergunta, o sistema precisa interpretar essa intenção da forma mais precisa possível. A pergunta é convertida em vetor e será executada uma pesquisa vetorial para encontrar os documentos mais relevantes no índice.</p><p>Os documentos encontrados são organizados e usados como contexto para compor um prompt estruturado, que é enviado ao modelo de linguagem. O modelo, então, gera a resposta considerando tanto a pergunta original quanto os documentos recuperados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Jr97dvcPwQm42E4O" /><figcaption><em>Fluxo da consulta do usuário até a resposta gerada pelo modelo.</em></figcaption></figure><h3>Desafios comuns na implementação de RAG</h3><p>Embora a arquitetura RAG seja conceitualmente simples, sua implementação prática envolve decisões que afetam diretamente a qualidade das respostas, a escalabilidade e a confiabilidade do sistema. Abaixo estão alguns dos desafios mais comuns encontrados ao implementar o RAG:</p><h4>Recuperação irrelevante</h4><p>Mesmo com bons embeddings, nem sempre os trechos recuperados são os mais úteis para responder à pergunta. Isso acontece quando o conteúdo é genérico ou pouco informativo. Em muitos casos, ajustes no chunking, uso de metadados e filtros adicionais são necessários para melhorar a precisão da recuperação.</p><h4>Confiança na resposta</h4><p>Mesmo com contexto relevante, modelos podem “alucinar”, ou seja, gerar respostas incorretas de forma convincente. Estratégias como limitar o modelo a apenas responder com base no contexto, aplicar guardrails, ou sinalizar a fonte da informação ajudam a tornar o sistema mais confiável e rastreável.</p><h4>Latência e performance</h4><p>A adição da etapa de recuperação pode aumentar o tempo de resposta, especialmente se o índice vetorial for grande ou mal estruturado. É importante otimizar a busca, limitar o número de trechos recuperados e considerar técnicas como caching ou pré-processamento para manter uma boa experiência de uso.</p><h4>Atualização da base de conhecimento</h4><p>Manter a base de documentos sempre atualizada sem comprometer a performance é um desafio constante. Isso envolve lidar com novos documentos, alterações em conteúdos existentes e remoção de informações obsoletas, etapas que impactam diretamente a qualidade das respostas geradas.</p><h4>Priorização e ordenação dos trechos recuperados</h4><p>Nem todo trecho recuperado tem o mesmo peso. RAGs mais robustos se beneficiam de uma camada de <em>reranking</em>, que reordena os resultados com base na relevância real para a pergunta. Ignorar essa etapa pode levar à montagem de prompts com contexto pouco útil ou redund</p><h3>Conclusão</h3><p>O RAG surge como uma resposta prática às limitações dos modelos de linguagem em cenários que exigem precisão, rastreabilidade e controle sobre a fonte das informações. Ao longo deste artigo, exploramos os fundamentos da arquitetura, seus componentes, como ingestão, recuperação e geração, além de desafios comuns enfrentados em sua implementação.</p><p>Mais do que uma solução técnica, RAG representa uma mudança de perspectiva: em vez de depender exclusivamente do que o modelo “aprendeu”, passamos a construir sistemas que geram respostas baseadas em contexto. Essa combinação abre caminho para aplicações mais seguras e adaptáveis a diferentes domínios.</p><p>À medida que o uso de LLMs se torna mais comum em produtos e serviços, entender como estruturar e aplicar uma arquitetura RAG pode ser um diferencial real na entrega de valor com inteligência artificial.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=059bb3b16736" width="1" height="1" alt=""><hr><p><a href="https://medium.com/inside-picpay/muito-al%C3%A9m-do-llm-porque-rag-importa-e-como-funciona-059bb3b16736">Muito além do LLM: porque RAG importa e como funciona</a> was originally published in <a href="https://medium.com/inside-picpay">Inside PicPay</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to ingest data to Elasticsearch through Airbyte]]></title>
            <link>https://medium.com/@andre.luiz1987/how-to-ingest-data-to-elasticsearch-through-airbyte-dd8d1a4ceccf?source=rss-9e072dc02cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd8d1a4ceccf</guid>
            <category><![CDATA[airbyte]]></category>
            <category><![CDATA[elasticsearch]]></category>
            <dc:creator><![CDATA[André Coelho]]></dc:creator>
            <pubDate>Mon, 24 Mar 2025 20:57:59 GMT</pubDate>
            <atom:updated>2025-03-24T20:57:59.228Z</atom:updated>
            <content:encoded><![CDATA[<p>Check out the article below, where I explore How to ingest data to Elasticsearch through Airbyte.</p><p><a href="https://www.elastic.co/search-labs/blog/airbyte-elasticsearch-ingest-data">Airbyte &amp; Elasticsearch: Ingesting data to Elastic via Airbyte - Elasticsearch Labs</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd8d1a4ceccf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to ingest data to Elasticsearch through LlamaIndex]]></title>
            <link>https://medium.com/@andre.luiz1987/how-to-ingest-data-to-elasticsearch-through-llamaindex-4527cef81ef9?source=rss-9e072dc02cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/4527cef81ef9</guid>
            <category><![CDATA[llamaindex]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[elasticsearch]]></category>
            <dc:creator><![CDATA[André Coelho]]></dc:creator>
            <pubDate>Mon, 10 Mar 2025 23:49:29 GMT</pubDate>
            <atom:updated>2025-03-10T23:49:29.947Z</atom:updated>
            <content:encoded><![CDATA[<p>Check out the article below, where I explore how to index and search for documents using RAG with LlamaIndex. If you’re interested in enhancing retrieval-augmented generation with efficient document processing, this one’s for you!</p><p><a href="https://www.elastic.co/search-labs/blog/elasticsearch-llamaindex-ingest-data">How to ingest data to Elasticsearch through LlamaIndex - Elasticsearch Labs</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4527cef81ef9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Basic Recommendations for Creating a Cluster and Indexes in Elasticsearch: Lessons Learned in…]]></title>
            <link>https://medium.com/@andre.luiz1987/basic-recommendations-for-creating-a-cluster-and-indexes-in-elasticsearch-lessons-learned-in-528d0bbe6902?source=rss-9e072dc02cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/528d0bbe6902</guid>
            <category><![CDATA[elasticsearch-tips]]></category>
            <dc:creator><![CDATA[André Coelho]]></dc:creator>
            <pubDate>Thu, 16 Jan 2025 18:45:01 GMT</pubDate>
            <atom:updated>2025-01-16T18:45:01.313Z</atom:updated>
            <content:encoded><![CDATA[<h3>Basic Recommendations for Creating a Cluster and Indexes in Elasticsearch: Lessons Learned in Practice</h3><p>Elasticsearch is a powerful tool for searching and analyzing data in real time, but its initial setup can be challenging, especially for beginners. Based on practical experience with AWS-managed clusters and also in self-hosted environments, I share some recommendations that can help you avoid headaches and ensure a stable and efficient environment.</p><h3>1. Cluster Planning</h3><h4>Choose the Right Size</h4><p>A poorly sized cluster can lead to performance issues or unnecessary costs. In AWS-managed environments, for example, it is easy to adjust the number of nodes and instance sizes as needed. For self-hosted clusters, evaluate the volume of data and expected traffic before deciding how many nodes you will need.</p><ul><li>Minimum of 3 Nodes: For high availability, I recommend at least 3 nodes (1 master and 2 data). This avoids issues such as split-brain.</li><li>Separation of Functions: In larger clusters, separate nodes by function (master, data, coordination, and ingestion) to optimize performance.</li></ul><h4>Security Is Not Optional</h4><p>Whether in a managed or in-house environment, security should be a priority. In managed clusters, many security settings are already enabled, but in self-hosted environments, it is essential to:</p><ul><li>Enable X-Pack Security for authentication and encryption.</li><li>Configure users and roles to control access to the cluster.</li></ul><h3>2. Index Configuration: Organization is Key</h3><h4>Field Mapping</h4><p>Define the field mapping before indexing data. This prevents issues with incorrect data types and facilitates searches and aggregations.</p><ul><li>Use keyword for fields that need to be filtered or aggregated.</li><li>Use text for fields that require text analysis (full-text search).</li></ul><h4><strong>Shards and Replicas</strong></h4><p>The configuration of shards and replicas is crucial for the performance and resilience of the cluster.</p><ul><li><strong>Shards</strong>: Start with 1 shard per 20–50 GB of data. Avoid very large shards (above 50 GB).</li><li><strong>Replicas</strong>: Configure at least 1 replica to ensure redundancy.</li></ul><h4><strong>Index Templates and ILM</strong></h4><p>For environments with many indices, use index templates and ILM (Index Lifecycle Management).</p><ul><li><strong>Templates</strong>: Apply default settings to new indices automatically.</li><li><strong>ILM</strong>: Manage the lifecycle of indices by moving data to colder nodes or deleting old indices.</li></ul><h3>3. Monitoring and Maintenance</h3><h4><strong>Real-Time Monitoring</strong></h4><p>Use tools to monitor the health of the cluster. Set up alerts for critical metrics such as memory usage, CPU, and disk space.</p><h4><strong>Backup and Restore</strong></h4><p>Never underestimate the importance of backups. Configure Snapshot and Restore to perform regular backups. On AWS, for example, this can be integrated with S3. In self-hosted environments, use a shared file system or a remote repository.</p><h3>4. Final Tips</h3><ul><li><strong>Avoid Oversized Indices</strong>: Split large indices into smaller ones based on time periods (e.g., logs by day or month).</li><li><strong>Test Before Production</strong>: Simulate workloads and adjust configurations before putting the cluster into production.</li><li><strong>Document Everything</strong>: Keep a record of configurations and decisions made. This simplifies maintenance and troubleshooting.</li></ul><h3>Conclusion</h3><p>Setting up an Elasticsearch cluster may seem complex, but with proper planning and the right practices, it is possible to create a stable and efficient environment. My recommendations are based on real-world experiences. Whatever your case may be, the key is to start simple, monitor closely, and adjust as needed.</p><p>What about you? Have you faced any challenges while configuring an Elasticsearch cluster? Share your experiences in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=528d0bbe6902" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Monitoring snapshots in Elasticsearch with Watcher]]></title>
            <link>https://medium.com/@andre.luiz1987/monitoring-snapshots-in-elasticsearch-with-watcher-01335a2eb2e6?source=rss-9e072dc02cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/01335a2eb2e6</guid>
            <category><![CDATA[elasticsearch-snapshot]]></category>
            <category><![CDATA[elasticsearch-watcher]]></category>
            <dc:creator><![CDATA[André Coelho]]></dc:creator>
            <pubDate>Sat, 11 Jan 2025 09:41:31 GMT</pubDate>
            <atom:updated>2025-01-11T09:41:31.764Z</atom:updated>
            <content:encoded><![CDATA[<p>Hello everyone, I hope you’re all doing well at the start of this new year. I also hope to write more this year compared to last year. It was a challenging year to dedicate time to the blog.</p><p>Today, I want to talk a bit about using the Watcher tool to monitor changes or anomalies in an Elasticsearch cluster. The motivation for this article came after I asked myself how to easily create an alert for snapshots not created. I’ve seen some questions about this, and while studying the topic, I realized that Watcher can be very useful for this purpose.</p><h3><strong>What is Watcher?</strong></h3><p>According to the official documentation:</p><blockquote>You can use Watcher to watch for changes or anomalies in your data and perform the necessary actions in response. For example, you might want to:</blockquote><blockquote>Monitor social media as another way to detect failures in user-facing automated systems like ATMs or ticketing systems. When the number of tweets and posts in an area exceeds a threshold of significance, notify a service technician.</blockquote><blockquote>Monitor your infrastructure, tracking disk usage over time. Open a helpdesk ticket when any servers are likely to run out of free space in the next few days.</blockquote><blockquote>Track network activity to detect malicious activity, and proactively change firewall configuration to reject the malicious user.</blockquote><blockquote>Monitor Elasticsearch, and send immediate notification to the system administrator if nodes leave the cluster or query throughput exceeds an expected range.</blockquote><blockquote>Track application response times and if page-load time exceeds SLAs for more than 5 minutes, open a helpdesk ticket. If SLAs are exceeded for an hour, page the administrator on duty.</blockquote><p>Thus, Watcher is an Elasticsearch monitoring tool that detects changes or anomalies in data and performs automated actions in response, such as notifications. It is used to monitor infrastructure, networks, and data in real time, ensuring quick responses to critical events.</p><p>An important point to understand is the components of Watcher, which are divided into:</p><ul><li><strong>Schedule</strong><br>Defines when a query will be executed to check the configured condition.</li><li><strong>Query</strong><br> The query that will be used as input to evaluate the condition.</li><li><strong>Condition</strong><br>Determines whether the actions will be executed or not. It can be a simple condition (always true) or more complex, using custom scripts.</li><li><strong>Actions</strong><br>The tasks performed if the condition is met, such as sending emails, pushing data to external systems via webhook, or indexing query results.</li></ul><p>I won’t go into detail about each option in each block, as the documentation can easily explain and clarify all doubts.</p><h3><strong>Creating a Snapshot Monitoring Alert</strong></h3><p>Putting it into practice, let’s configure a Watcher to monitor the snapshots created. It is a good practice to regularly take snapshots of your cluster’s indices, ensuring data security and integrity. With the Watcher, we can be notified if no snapshot is created, enabling quick corrective actions.</p><p>Let’s start by defining the Watcher’s components, beginning with the trigger:</p><pre>&quot;trigger&quot; : { <br>    &quot;schedule&quot; : {<br>      &quot;interval&quot; : &quot;24h&quot;<br>    }<br>  }</pre><p>Here, we are specifying that the Watcher interval will be 24 hours, meaning it will run every 24 hours.</p><p>Next, we define the input, which indicates where the data to be analyzed will come from. Since I need to access the list of snapshots, I use the http input type and configure it to execute the _snapshot/backup/_all command.</p><pre>  &quot;input&quot; : { <br>    &quot;http&quot; : {<br>      &quot;request&quot; : {<br>        &quot;host&quot; : &quot;localhost&quot;,<br>        &quot;port&quot; : 9200,<br>        &quot;path&quot; : &quot;_snapshot/backup/_all&quot;<br>      }<br>    }<br>  },</pre><p>Next, I configure the condition component, which will determine whether or not the notification action is executed. Below, I created a script that retrieves the end date of the last snapshot execution and calculates if the difference from the current day is greater than 1 day. If true, the notification will be sent.</p><pre>  &quot;condition&quot; : {<br>    &quot;script&quot; : {<br>      &quot;source&quot; : &quot;&quot;&quot;<br>        def lastSnapshot = ctx.payload.snapshots[ctx.payload.total - 1];<br>        long lastDateMillis = lastSnapshot.end_time_in_millis;<br>        long currentDateMillis = new Date().getTime();<br>        long diffMillis = lastDateMillis &gt; currentDateMillis<br>                            ? (lastDateMillis - currentDateMillis)<br>                            : (currentDateMillis - lastDateMillis);<br>        long diffDays = diffMillis / (1000 * 60 * 60 * 24);<br>        return diffDays &gt; 1;<br>        &quot;&quot;&quot;<br>    }<br>  }</pre><p>Finally, here we configured an action. In this action, I chose to send a notification message via webhook. In this example, I used a service like <a href="https://webhook.site/">https://webhook.site/</a> because our goal is a quick and simple practice.</p><pre>  &quot;actions&quot; : {<br>  &quot;alert_webhook&quot; : { <br>        &quot;throttle_period&quot; : &quot;60s&quot;, <br>        &quot;webhook&quot; : {<br>        &quot;method&quot; : &quot;POST&quot;, <br>        &quot;url&quot; : &quot;https://webhook.site/a5acba89-f1fd-4918-86f4-1201fc47f6d9&quot;, <br>        &quot;body&quot; : &quot;Alert: No Snapshots Created in the Last 24 Hours&quot; <br>        }<br>    }<br>  }</pre><p>Now we have our complete Watcher script, see below how it looks:</p><pre>PUT _watcher/watch/snapshot_errors<br>{<br>  &quot;trigger&quot; : { <br>    &quot;schedule&quot; : {<br>      &quot;interval&quot; : &quot;24h&quot;<br>    }<br>  },<br>  &quot;input&quot; : { <br>    &quot;http&quot; : {<br>      &quot;request&quot; : {<br>        &quot;host&quot; : &quot;localhost&quot;,<br>        &quot;port&quot; : 9200,<br>        &quot;path&quot; : &quot;_snapshot/backup/_all&quot;<br>      }<br>    }<br>  },<br>  &quot;condition&quot; : {<br>    &quot;script&quot; : {<br>      &quot;source&quot; : &quot;&quot;&quot;<br>        def lastSnapshot = ctx.payload.snapshots[ctx.payload.total - 1];<br>        long lastDateMillis = lastSnapshot.end_time_in_millis;<br>        long currentDateMillis = new Date().getTime();<br>        long diffMillis = lastDateMillis &gt; currentDateMillis<br>                            ? (lastDateMillis - currentDateMillis)<br>                            : (currentDateMillis - lastDateMillis);<br>        long diffDays = diffMillis / (1000 * 60 * 60 * 24);<br>        return diffDays &gt; 1;<br>        &quot;&quot;&quot;<br>    }<br>  },<br>  &quot;actions&quot; : {<br>  &quot;alert_webhook&quot; : { <br>        &quot;throttle_period&quot; : &quot;60s&quot;, <br>        &quot;webhook&quot; : {<br>        &quot;method&quot; : &quot;POST&quot;, <br>        &quot;url&quot; : &quot;https://webhook.site/a5acba89-f1fd-4918-86f4-1201fc47f6d9&quot;, <br>        &quot;body&quot; : &quot;Alert: No Snapshots Created in the Last 24 Hours&quot; <br>        }<br>    }<br>  }<br>}</pre><p>And we can see that it is working:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GgPvoQhQcpXcc_8LxLuPoQ.png" /></figure><p>This was the practice, and I hope it was useful for you. See you next time!</p><h3>References</h3><ul><li><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/watcher-getting-started.html">Getting started with Watcher</a></li><li><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/actions-webhook.html">Watcher webhook action</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=01335a2eb2e6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>