We built Smooth because existing browser agents were slow, expensive, and unreliable. Even simple tasks could take minutes and cost dollars in API credits.

We started as users of Browser Use, but the pain was obvious. So we built something better. Smooth is 5x faster, 7x cheaper, and more reliable. And along the way, we discovered two principles that make agents actually work.

(1) Think like the LLM (https://x.com/karpathy/status/1937902205765607626).

The most important thing is to put yourself in the shoes of the LLM. This is especially important when designing the context. How you present the problem to the LLM determines whether it succeeds or fails. Imagine playing chess with an LLM. You could represent the board in countless ways - image, markdown, JSON, etc. Which one you choose matters more than any other part of the system. Clean, intuitive context is everything. We call this LLM-Ex.

(2) Let them write code (https://arxiv.org/pdf/2401.07339)

Tool calling is limited. If you want agents that can handle complex logic and manipulate objects reliably, you need code. Coding offers a richer, more composable action space. Suddenly, designing for the agent feels more like designing for a human developer, which makes everything simpler. By applying these two principles religiously, we realized you don't need huge models to get reliable results. Small, efficient models can get you higher reliability while also getting human-speed navigation and a huge cost reduction.

How it works:

1. Extract: we look at the webpage and extract all relevant elements by looking at the rendered page.

2. Filter and Clean: then, we use some simple heuristics to clean up the webpage. If an element is not interactive, e.g. because a banner is covering it, we remove it.

3. Recursively separate sections: we use several heuristics to represent the webpage in a way that is both LLM-friendly and as similar as possible to how humans see it.

We packaged Smooth in an easy API with instant browser spin-up, custom proxies, persistent sessions, and auto-CAPTCHA solvers. Our goal is to give you this infrastructure so that you can focus on what's important: building great apps for your users.

Before we built this, Antonio was at Amazon, Luca was finishing a PhD at Oxford, and we've been obsessed with reliable AI agents for years. Now we know: if you want agents to work reliably, focus on the context.

Try it for free at https://zero.circlemind.co/developer

Docs are here: https://docs.circlemind.co

Demo video: https://youtu.be/18v65oORixQ

We'd love feedback :)

Comments URL: https://news.ycombinator.com/item?id=45027597

Points: 54

# Comments: 16

Hope this can help!

Building a good RAG pipeline these days takes a lot of manual optimizations. Most engineers intuitively start from naive RAG: throw everything in a vector database and hope that semantic search is powerful enough. This can work for use cases where accuracy isn’t too important and hallucinations are tolerable, but it doesn’t work for more difficult queries that involve multi-hop reasoning or more advanced domain understanding. Also, it’s impossible to debug it.

To address these limitations, many engineers find themselves adding extra layers like agent-based preprocessing, custom embeddings, reranking mechanisms, and hybrid search strategies. Much like the early days of machine learning when we manually crafted feature vectors to squeeze out marginal gains, building an effective RAG system often becomes an exercise in crafting engineering “hacks.”

Earlier this year, Microsoft seeded the idea of using Knowledge Graphs for RAG and published GraphRAG - i.e. RAG with Knowledge Graphs. We believe that there is an incredible potential in this idea, but existing implementations are naive in the way they create and explore the graph. That’s why we developed Fast GraphRAG with a new algorithmic approach using good old PageRank.

There are two main challenges when building a reliable RAG system:

(1) Data Noise: Real-world data is often messy. Customer support tickets, chat logs, and other conversational data can include a lot of irrelevant information. If you push noisy data into a vector database, you’re likely to get noisy results.

(2) Domain Specialization: For complex use cases, a RAG system must understand the domain-specific context. This requires creating representations that capture not just the words but the deeper relationships and structures within the data.

Our solution builds on these insights by incorporating knowledge graphs into the RAG pipeline. Knowledge graphs store entities and their relationships, and can help structure data in a way that enables more accurate and context-aware information retrieval. 12 years ago Google announced the knowledge graph we all know about [1]. It was a pioneering move. Now we have LLMs, meaning that people can finally do RAG on their own data with tools that can be as powerful as Google’s original idea.

Before we built this, Antonio was at Amazon, while Luca and Yuhang were finishing their PhDs at Oxford. We had been thinking about this problem for years and we always loved the parallel between pagerank and the human memory [2]. We believe that searching for memories is incredibly similar to searching the web.

Here’s how it works:

- Entity and Relationship Extraction: Fast GraphRAG uses LLMs to extract entities and their relationships from your data and stores them in a graph format [3].

- Query Processing: When you make a query, Fast GraphRAG starts by finding the most relevant entities using vector search, then runs a personalized PageRank algorithm to determine the most important “memories” or pieces of information related to the query [4].

- Incremental Updates: Unlike other graph-based RAG systems, Fast GraphRAG natively supports incremental data insertions. This means you can continuously add new data without reprocessing the entire graph.

- Faster: These design choices make our algorithm faster and more affordable to run than other graph-based RAG systems because we eliminate the need for communities and clustering.

Suppose you’re analyzing a book and want to focus on character interactions, locations, and significant events:

  from fast_graphrag import GraphRAG
  
  DOMAIN = "Analyze this story and identify the characters. Focus on how they interact with each other, the locations they explore, and their relationships."
  
  EXAMPLE_QUERIES = [
      "What is the significance of Christmas Eve in A Christmas Carol?",
      "How does the setting of Victorian London contribute to the story's themes?",
      "Describe the chain of events that leads to Scrooge's transformation.",
      "How does Dickens use the different spirits (Past, Present, and Future) to guide Scrooge?",
      "Why does Dickens choose to divide the story into \"staves\" rather than chapters?"
  ]
  
  ENTITY_TYPES = ["Character", "Animal", "Place", "Object", "Activity", "Event"]
  
  grag = GraphRAG(
      working_dir="./book_example",
      domain=DOMAIN,
      example_queries="\n".join(EXAMPLE_QUERIES),
      entity_types=ENTITY_TYPES
  )
  
  with open("./book.txt") as f:
      grag.insert(f.read())
  
  print(grag.query("Who is Scrooge?").response)

This is the kind of infrastructure that GenAI apps need to handle large-scale real-world data. Our goal is to give you this infrastructure so that you can focus on what’s important: building great apps for your users without having to care about manually engineering a retrieval pipeline. In the managed service, we also have a suite of UI tools for you to explore and debug your knowledge graph.

We have a free hosted solution with up to 100 monthly requests. When you’re ready to grow, we have paid plans that scale with you. And of course you can self host our open-source engine.

Give us a spin today at https://circlemind.co and see our code at https://github.com/circlemind-ai/fast-graphrag

We’d love feedback :)

[1] https://blog.google/products/search/introducing-knowledge-gr...

[2] Griffiths, T. L., Steyvers, M., & Firl, A. (2007). Google and the Mind: Predicting Fluency with PageRank. Psychological Science, 18(12), 1069–1076. http://www.jstor.org/stable/40064705

[3] Similarly to Microsoft’s GraphRAG: https://github.com/microsoft/graphrag

[4] Similarly to OSU’s HippoRAG: https://github.com/OSU-NLP-Group/HippoRAG

https://vhs.charm.sh/vhs-4fCicgsbsc7UX0pemOcsMp.gif

Comments URL: https://news.ycombinator.com/item?id=42174829

Points: 457

# Comments: 119