Exa + Graphlit: Neural Search That Builds Your Knowledge Base

Exa (formerly Metaphor) pioneered neural web search — finding content based on meaning rather than keyword matching. Ask Exa for "startups building developer tools for AI agents" and it understands what you mean, returning results that traditional search engines miss.

Graphlit integrates Exa as a native search backend. When you search with Exa through Graphlit, results are automatically ingested, processed, and connected to your knowledge base. Neural search discovery combined with semantic infrastructure.

This means you can find exactly what you're looking for with Exa's semantic understanding, then build persistent knowledge from those discoveries.

Table of Contents

1. TL;DR — Quick Comparison
2. What Exa Does Well
3. What Graphlit Adds
4. The Integration
5. When to Use Exa Directly
6. When to Use Exa Through Graphlit
7. Integration Example

TL;DR — Quick Comparison

What Exa Does Well

Exa reimagined web search for the AI era:

Neural Search

Traditional search matches keywords. Exa matches meaning. Search for "companies disrupting legal tech with AI" and Exa understands the concept, not just the words.

Find Similar

Give Exa a URL and find similar content across the web. Found a great article? Discover more like it — based on semantic similarity, not link analysis.

Natural Language Queries

Write queries like you'd explain to a person:

• "Technical blog posts about building RAG systems with knowledge graphs"
• "Startups founded in 2024 working on AI infrastructure"
• "Academic papers on long-term memory for AI agents"

Code Search (Exa Code)

Specialized search for code repositories, technical documentation, and developer content.

Clean Results

Exa's results tend to be high-quality, substantive content — less SEO spam than traditional search.

What Graphlit Adds

Graphlit turns Exa discoveries into persistent knowledge:

Full Content Ingestion

Exa finds the URLs. Graphlit scrapes the full content, extracting clean Markdown — not just snippets.

Automatic Processing

Every search result is:

• Scraped for complete content
• Converted to structured Markdown
• Embedded for your vector search
• Entity-extracted (people, companies, technologies)
• Connected to your knowledge graph

Build Knowledge Over Time

Exa searches are ephemeral — great for discovery. Graphlit makes them permanent. Your research accumulates into a searchable knowledge base.

Unified Search

Search Exa discoveries alongside your documents, emails, Slack messages — everything in one semantic query.

Find Similar, Then Ingest

Use Exa's "find similar" to discover content, then automatically ingest and process everything you find.

Automated Research Feeds

Set up recurring Exa searches that automatically discover and ingest new content. Monitor topics, track competitors, stay current.

The Integration

Exa is available through Graphlit's SearchServiceTypes:

import { Graphlit, Types } from 'graphlit-client';

const client = new Graphlit();

// Neural search with Exa
const results = await client.searchWeb(
    "technical approaches to persistent memory in AI agents",
    Types.SearchServiceTypes.Exa,
    10
);

// Results include semantically relevant URLs
// Ingest full content from discoveries
for (const result of results.searchWeb?.results || []) {
    await client.ingestUri(result.uri, result.title);
}

For code-focused search:

// Code search with Exa Code
const codeResults = await client.searchWeb(
    "open source RAG frameworks with knowledge graph support",
    Types.SearchServiceTypes.ExaCode,
    10
);

Automated research feed:

// Create an Exa search feed
const feed = await client.createFeed({
    name: "AI Memory Research",
    type: Types.FeedTypes.Search,
    search: {
        type: Types.SearchServiceTypes.Exa,
        text: "AI agent memory architectures and frameworks",
        readLimit: 10
    },
    schedulePolicy: {
        recurrenceType: Types.TimedPolicyRecurrenceTypes.Weekly
    }
});

// Exa discovers new content weekly
// Graphlit automatically ingests and processes it

When to Use Exa Directly

Use Exa's API directly when:

• Quick discovery: Finding content without persistence needs
• Research exploration: Browsing results before deciding what to keep
• Agent tool calls: Simple search tools in agent frameworks
• Existing pipeline: You've built your own ingestion infrastructure
• Find similar only: Using the similarity feature for recommendations

Exa is great as a discovery tool when you just need to find things.

When to Use Exa Through Graphlit

Use Graphlit's Exa integration when:

• Building knowledge bases: Research that accumulates into searchable knowledge
• Full content needed: You want the complete articles, not snippets
• Entity tracking: Extract and connect people, companies, technologies
• Unified search: Exa discoveries alongside your other content
• Automated research: Recurring searches that auto-ingest results
• RAG applications: Neural search results as sources for AI conversations
• Team knowledge: Shared research accessible to multiple users

The integration turns Exa's semantic discovery into persistent, connected knowledge.

Integration Example

Exa Direct: Discover and Done

from exa_py import Exa

exa = Exa(api_key="...")

# Neural search
results = exa.search(
    "technical blog posts about building knowledge graphs for RAG",
    num_results=10,
    type="neural"
)

# Results are great discoveries — but ephemeral
for result in results.results:
    print(result.title, result.url)
    # Now what? Manual review, manual saving, manual processing...

# To build knowledge from discoveries:
# 1. Scrape each URL
# 2. Extract clean content
# 3. Generate embeddings
# 4. Store in vector database
# 5. Extract entities
# 6. Connect relationships
# 7. Build search index

Graphlit with Exa: Discover to Knowledge

import { Graphlit, Types } from 'graphlit-client';

const client = new Graphlit();

// Neural search with Exa
const results = await client.searchWeb(
    "technical blog posts about building knowledge graphs for RAG",
    Types.SearchServiceTypes.Exa,
    10
);

// Ingest all discoveries into knowledge base
for (const result of results.searchWeb?.results || []) {
    await client.ingestUri(result.uri, result.title);
}

// All content is now:
// - Full pages scraped
// - Clean Markdown extracted
// - Embedded for vector search
// - Entities identified (authors, companies, technologies)
// - Connected in knowledge graph
// - Searchable alongside everything else

// Or set up automated discovery
const feed = await client.createFeed({
    name: "Knowledge Graph Research",
    type: Types.FeedTypes.Search,
    search: {
        type: Types.SearchServiceTypes.Exa,
        text: "knowledge graphs for AI applications",
        readLimit: 10
    },
    schedulePolicy: {
        recurrenceType: Types.TimedPolicyRecurrenceTypes.Weekly
    }
});

// Search everything — Exa discoveries + your documents
const contents = await client.queryContents({
    search: "graph-based RAG architectures"
});

// RAG conversation with research as sources
const response = await client.promptConversation(
    "What are the main approaches to using knowledge graphs in RAG systems?",
    conversationId,
    { id: specificationId }
);

Exa vs. Tavily

Both are Graphlit search backends. Choose based on use case:

Use Exa for semantic discovery ("content like this"). Use Tavily for direct search ("news about X").

Both integrate the same way in Graphlit — results flow into your knowledge base automatically.

Summary

Exa pioneered neural web search — finding content by meaning, not keywords. Its semantic understanding discovers content that traditional search misses.

Graphlit integrates Exa as a native backend, adding:

• Full content ingestion from discoveries
• Automatic embedding and entity extraction
• Persistent knowledge base storage
• Unified search across all content
• Automated research feeds
• RAG-ready conversations

Use Exa directly for quick semantic discovery. Use Exa through Graphlit when discoveries should become searchable, connected knowledge.

Explore Graphlit Features:

• Web Scraping and Search — Web discovery and ingestion
• Building Knowledge Graphs — Entity extraction and connection
• Complete Guide to Search — Hybrid semantic search
• Data Connectors — All integration options

Learn More:

• Graphlit Documentation
• Exa Documentation
• Schedule a Demo
• Join our Discord

Neural search discovers meaning. Graphlit turns discoveries into knowledge.