OpenAI's Retrieval API promises to simplify semantic search over your data with vector stores, automatic chunking, and hybrid search. Upload files, run queries, and get relevant results with citations. For GPT-based document retrieval, it's a solid foundation.
But here's what they don't tell you: OpenAI Retrieval is still fundamentally file-only. No audio transcription. No video understanding. No live Slack monitoring. No automated feed ingestion. And critically, no escape from the OpenAI/GPT ecosystem.
If you're choosing between OpenAI Retrieval and Graphlit, you need to understand where OpenAI's vector-search-only approach breaks down — and why Graphlit's multimodal, multi-LLM semantic platform is built for agents that operate in the real world, not just in document repositories.
Table of Contents
- TL;DR — Quick Feature Comparison
- Understanding the Platforms
- The File-Only Problem: What OpenAI Retrieval Can't Do
- Ingestion: Manual Uploads vs. Automated Orchestration
- Multimodal Blindness: No Audio, Video, or Image Intelligence
- Model Lock-In: GPT-Only vs. Multi-LLM Flexibility
- Search Capabilities: Hybrid Vector Search vs. Knowledge Graphs
- Agent Infrastructure: Retrieval Primitive vs. Full Platform
- Developer Experience and APIs
- Pricing and Storage Limits
- Use Cases: When to Choose Each
- Final Verdict
TL;DR — Quick Feature Comparison
Understanding the Platforms
What is OpenAI Retrieval?
OpenAI Retrieval is a vector store API integrated into the OpenAI platform. It provides semantic search over uploaded files by automatically chunking, embedding (using OpenAI's embedding models), and indexing your documents.
The workflow is straightforward:
- Create a vector store
- Upload files (PDFs, DOCX, code, markdown, etc.)
- Query with semantic search
- Get results with similarity scores and citations
- Optionally synthesize responses using GPT models
It supports hybrid search (combining vector and keyword matching), attribute filtering (metadata-based queries), query rewriting for optimization, and customizable chunking strategies. For GPT-based document QA, it's a capable retrieval layer.
But that's where it stops. No multimodal processing. No live data. No model flexibility.
What is Graphlit?
Graphlit is an semantic memory platform powered by the Model Context Protocol (MCP). It's not a retrieval API — it's a complete platform for building agents with persistent, multimodal memory across all information sources.
Graphlit provides:
- Live data connectors for 30+ sources (Slack, Gmail, GitHub, RSS, YouTube, etc.)
- Multimodal processing (audio transcription with diarization, video understanding, image OCR)
- Knowledge graph construction (entity extraction, relationship modeling, graph traversal)
- Multi-LLM support (OpenAI, Anthropic, Google, Meta, custom models)
- Agent workflows (conversation management, tool calling, MCP integration)
- Continuous synchronization (automated feeds with real-time updates)
Where OpenAI Retrieval is a search primitive, Graphlit is an semantic platform.
The File-Only Problem: What OpenAI Retrieval Can't Do
OpenAI Retrieval supports about 25 file types — documents, presentations, code, and PDFs. But modern agents need to process information that doesn't live in static files:
❌ No Audio Transcription
Your team records meetings, customer calls, and podcasts. OpenAI Retrieval cannot transcribe or process audio. You'd need to manually transcribe, save as text, and upload — a workflow that defeats the purpose of automation.
Graphlit: Automatically transcribes audio files and feeds (podcasts, meeting recordings) with speaker diarization, timestamps, and searchable metadata.
❌ No Video Understanding
Videos contain rich information: spoken dialogue, visual context, on-screen text. OpenAI Retrieval cannot process video — it only handles static documents.
Graphlit: Extracts audio tracks, transcribes dialogue, runs OCR on frames, and indexes video content as searchable, citable knowledge.
❌ No Image Intelligence
Screenshots, infographics, and diagrams with embedded text are invisible to OpenAI Retrieval. No OCR, no visual understanding.
Graphlit: Runs OCR on images, extracts text from PDFs with embedded images, and makes visual content queryable.
❌ No Live Data Sources
Agents need to monitor Slack conversations, GitHub issues, email threads, RSS feeds, and social media. OpenAI Retrieval requires manual file export and upload for every update.
Graphlit: Connects directly to 30+ live sources with automated polling or webhooks, continuously syncing new information without manual steps.
❌ No Structured Data Ingestion
What about CRM data, database exports, API responses, or structured JSON? OpenAI Retrieval can handle JSON files but doesn't understand relationships or build queryable structures beyond keyword/vector matching.
Graphlit: Ingests structured data, extracts entities and relationships, and links them into a knowledge graph for relational queries.
💡 Key Point: OpenAI Retrieval works for static document collections. Real agents need live, multimodal, structured memory — which requires orchestration, not just a vector store API.
Ingestion: Manual Uploads vs. Automated Orchestration
OpenAI Retrieval requires developers to:
- Export data from sources (Slack, email, GitHub, etc.)
- Convert to supported formats (PDF, DOCX, TXT, etc.)
- Upload via API (with 512 MB per file limit)
- Re-upload manually whenever content changes
- Manage batch operations for multiple files
This works for one-time document indexing. It fails catastrophically for agents that need current information.
Graphlit provides:
- 30+ pre-built connectors: Slack, Discord, Gmail, GitHub, Jira, Linear, RSS, YouTube, web scraping, and more
- Automated feed synchronization: Continuous polling or webhook-based updates
- Incremental ingestion: Only processes new/changed content
- File ingestion too: Supports manual uploads when needed
- Multi-format support: Documents, audio, video, images, structured data, web pages
If your agent monitors a GitHub repository for issue updates, Graphlit ingests new issues automatically. With OpenAI Retrieval, you'd need to manually export GitHub data and re-upload it repeatedly — an untenable workflow for production systems.
Multimodal Blindness: No Audio, Video, or Image Intelligence
OpenAI Retrieval supports ~25 static file types (documents, code, PDFs, presentations) but has zero multimodal understanding:
Audio Blindness
- ❌ Cannot transcribe audio files
- ❌ Cannot process podcast feeds
- ❌ Cannot extract meeting audio
- ❌ Cannot identify speakers or timestamps
Graphlit: Transcribes audio with speaker diarization, timestamps, keyword extraction, and searchable transcripts. Agents can answer "What did Sarah say about pricing in the Q3 call?"
Video Blindness
- ❌ Cannot process video files
- ❌ Cannot extract audio from video
- ❌ Cannot run OCR on video frames
- ❌ Cannot understand visual context or scene changes
Graphlit: Extracts audio tracks, transcribes dialogue, runs OCR on key frames, and indexes video as searchable content with time-coded citations.
Image Blindness
- ❌ Cannot extract text from images (no OCR)
- ❌ Cannot process screenshots or diagrams
- ❌ Cannot understand visual layouts or embedded text
Graphlit: Runs OCR on images, extracts embedded text from PDFs, and makes visual content queryable.
This isn't a minor gap — it's an architectural limitation. Modern agents operate in multimodal environments. Restricting them to text-only documents is like building a smartphone that can't take photos.
Model Lock-In: GPT-Only vs. Multi-LLM Flexibility
OpenAI Retrieval is GPT-only. You cannot use it with:
- Anthropic's Claude (Opus, Sonnet, Haiku)
- Google's Gemini
- Meta's Llama
- Mistral, Cohere, or other providers
- Custom fine-tuned models
- Local models (Ollama, LM Studio)
If you've built your agent on Claude or a custom model, you'll need to switch your entire LLM stack to use OpenAI Retrieval. If OpenAI changes pricing or API terms, you're locked in. If GPT's performance regresses (as it sometimes does between updates), you have no alternative.
Graphlit is model-agnostic:
- Works with any LLM (Model Context Protocol)
- Supports OpenAI, Anthropic, Google, Meta, and custom models
- Allows per-conversation model selection
- No vendor lock-in — switch models at any time
This flexibility is critical for production systems where LLM landscape changes rapidly. Betting on a single vendor's API is a liability, not a strategy.
Search Capabilities: Hybrid Vector Search vs. Knowledge Graphs
OpenAI Retrieval offers hybrid search:
- Semantic search via vector embeddings (text-embedding-3-small/large)
- Keyword search via sparse text matching
- Reciprocal rank fusion (RRF) to combine both
- Attribute filtering for metadata queries
- Query rewriting for optimization
- Customizable ranking with score thresholds
This is better than pure vector search (like Google File Search), but it's still fundamentally limited to similarity matching. If your agent needs to answer "Who collaborated with Alice on the API redesign?" or "What decisions changed between January and March?", hybrid search alone won't suffice.
Graphlit combines:
- Semantic vector search (like OpenAI Retrieval)
- Keyword search with BM25 ranking
- Knowledge graph traversal (entity-aware retrieval)
- Relationship queries ("Find content where Alice and Bob collaborated")
- Temporal reasoning ("Show discussions before the product launch")
- Entity extraction (people, organizations, places, events)
Graphlit automatically extracts entities and models relationships. Agents can query not just by similarity, but by who, what, when, and how things connect.
✅ Example: "What did Sarah discuss with the engineering team about API pricing between March and June?" — Graphlit understands
Sarah(person),engineering team(organization),API pricing(topic), and the temporal constraint. OpenAI Retrieval only matches text similarity and basic date filtering.
Agent Infrastructure: Retrieval Primitive vs. Full Platform
OpenAI Retrieval provides semantic search. That's it. To build a functional agent, you still need:
- Conversation state management
- Multi-turn dialogue handling
- Tool/function calling orchestration
- User authentication and isolation
- Observability and debugging
- Rate limiting and error recovery
- Workflow automation
You're responsible for building all of this yourself — or cobbling together multiple services.
Graphlit provides the complete stack:
- Conversation management: Multi-turn dialogues with context persistence
- MCP tool integration: Agents can call external tools (APIs, databases, services)
- Workflow automation: Real-time hooks when content is ingested or updated
- User isolation: Per-user knowledge graphs and conversation history
- Multi-tenant architecture: Secure, isolated data per customer
- Observability: Built-in logging, monitoring, and debugging tools
- Feed orchestration: Manage multiple data sources with scheduling and prioritization
OpenAI Retrieval is a component you integrate. Graphlit is a platform you build on.
Developer Experience and APIs
OpenAI Retrieval
- REST API for vector store management
vector_stores.create()andvector_stores.files.upload_and_poll()vector_stores.search()for queries- Batch operations for multiple files
- Attribute updates for metadata
- Python, JavaScript, and REST clients
- Managed infrastructure on OpenAI platform
The API surface is focused but limited — you get retrieval with filtering, but no broader orchestration capabilities.
Graphlit
- Unified GraphQL API for ingestion, query, and chat
- SDKs for Python, JavaScript/TypeScript, C#
- UI dashboard for monitoring, testing, and debugging
- MCP integration for tool calling and agent workflows
- Workflow APIs for automation and real-time hooks
- Feed management for connector configuration
- Fully managed, auto-scaling infrastructure
Graphlit's API is broader because it handles the entire agent lifecycle, not just document retrieval.
Pricing and Storage Limits
OpenAI Retrieval
- Storage: 1 GB free, then $0.10/GB/day
- File limits: 512 MB per file, 5M tokens per file max
- Chunking: Default 800 tokens/chunk, 400 token overlap (configurable)
- Expiration policies: Set TTL to auto-delete old vector stores
- No embedding costs at query time (included in storage pricing)
Pricing is straightforward but scales linearly with storage. For large document collections, costs can add up quickly.
Graphlit
- Free tier: 100 credits (generous for testing and small projects)
- Paid plans: Starting at $49/month with flexible credit allocations
- Storage: Included in plan (no per-GB daily charges)
- File limits: Flexible based on plan tier
- Multimodal processing: Transcription, OCR, and video processing included
Graphlit's pricing covers storage, processing, and infrastructure — not just storage alone.
Use Cases: When to Choose Each
Choose OpenAI Retrieval If:
- You only need static document retrieval
- Your use case is GPT-specific (no model flexibility needed)
- You have no audio, video, or live data requirements
- You're building a simple QA bot over a fixed document set
- You want hybrid search but not knowledge graphs
- You're already deeply invested in the OpenAI ecosystem
Choose Graphlit If:
- You need live data sources (Slack, GitHub, email, RSS, etc.)
- You require multimodal processing (audio transcription, video understanding, OCR)
- You want LLM flexibility (OpenAI, Anthropic, Google, custom models)
- You're building production agents with conversation management and tool calling
- You need knowledge graphs for entity extraction and relationship modeling
- You want continuous synchronization without manual re-uploads
- You're building multi-tenant SaaS with per-user isolation
- You need orchestration, not just retrieval
Final Verdict: Retrieval is Necessary, But Not Sufficient
OpenAI Retrieval is a solid vector store API — it's well-designed, performant, and integrates cleanly with GPT models. For pure document retrieval in the OpenAI ecosystem, it's a reasonable choice.
But it's not an agent platform. It's a file upload API with semantic search.
Real agents need:
- ✅ Multimodal understanding (audio, video, images)
- ✅ Live data connectors (Slack, GitHub, email, feeds)
- ✅ Model flexibility (OpenAI, Anthropic, Google, custom)
- ✅ Knowledge graphs (entity extraction, relationship modeling)
- ✅ Agent workflows (conversations, tools, automation)
- ✅ Continuous synchronization (no manual re-uploads)
Graphlit provides all of this.
If you're building agents that operate in the real world — agents that listen, watch, monitor, and synthesize information across dozens of sources and formats — you need infrastructure that goes beyond vector search.
That's why we built Graphlit.
Explore Graphlit Features:
- Data Connectors - 30+ connectors for Slack, Gmail, GitHub, and more
- Multimodal Processing - Audio transcription, video understanding, OCR
- Building Knowledge Graphs - Automatic entity extraction and relationship modeling
- Complete Guide to Search - Hybrid search and graph traversal
- Agent Workflows - Conversation management and MCP tool integration
Learn More:
Vector search is necessary. But it's not sufficient. Agents need orchestration.