Recap: Arango Community Meetup
This month’s Arango community meetup tackled a question more teams are asking as they move AI from pilots into production: why does connected data make AI smarter? Mark Milinkovich, Director of Product Marketing at Arango, opened the session, and Daniel Morris, Arango’s Lead Solutions Architect based in the UK, walked the group through both the thinking behind graph-native context and a live demo of Contextus, an application he built to show what’s possible on top of the Arango Contextual Data Platform.
Why now: from human-to-machine to machine-to-machine
Mark opened by framing the shift underway in enterprise AI. The first wave of GenAI architecture — dashboards, chatbots — was built for human-to-machine interaction, where a person is in the loop to catch a wrong or incomplete answer. Agentic AI changes that equation. When an agent is acting, deciding, and executing autonomously inside a workflow, there’s no person double-checking each step in real time — which means the workflow needs to be precise. An agent that hallucinates or works from incomplete context doesn’t just produce a bad chat response; it can trigger a real business action downstream. That’s the gap Arango’s Contextual Data Platform is built to close: grounding agents, assistants, and applications in an organization’s own domain-specific knowledge so their answers are more trusted and accurate.
A quick platform primer
Daniel walked through the architecture in three layers:
- Ingestion, unified. Structured data (CRMs, ERPs), semi-structured data (JSON, event streams), and unstructured content (emails, slides, documents) are all supported natively, with unstructured formats parsed and chunked automatically at ingestion — no manual pre-processing, and no taxonomy or ontology work required up front. AutoGraph, Arango’s ingestion engine, runs community-detection clustering to discover the natural domains in the data and resolves entities so the same person, product, or system mentioned a dozen different ways across a dozen documents gets recognized as one thing.
- Retrieval, adaptive. AutoRAG decides per question, at runtime, whether graph traversal, vector search, or a blend of both will produce the best answer — merging and ranking results before they ever reach the LLM as context, which also keeps token usage down.
- Governance, built in. Full lineage, role-based access, and an audit trail mean every entity and passage traces back to its source, in the UI and the CLI. It’s a live graph, not a static snapshot — new sources can be added and only that slice of the graph gets rebuilt.
All of it runs on one graph-native, multi-model engine — graph, document, vector, and key-value data together, queried through a single language (AQL) — rather than separate systems bolted together. Agents and applications reach it directly through a REST API, official drivers and SDKs, or as an MCP server, and the platform is model-agnostic: OpenAI, Anthropic, Gemini, or your own fine-tuned or quantized models all plug in the same way.
Why relationships-as-data matters
Before the demo, Daniel made the underlying graph concept concrete. In a relational database, a relationship like “this customer placed this order” doesn’t exist as an object — it’s recomputed every time by matching keys across tables, and every additional hop (which products were in that order? which supplier shipped them?) means another fresh match. In Arango, that relationship is written once, as an edge, and traversed as a direct lookup. The practical payoff: a three-hop traversal costs roughly the same whether the graph holds a thousand connections or a billion, because cost scales with the number of edges walked, not the size of the underlying collections.
Live demo: Contextus, a graph-guided discovery agent
The centerpiece of the session was Contextus — not a shipped Arango product, but an application Daniel built using Arango’s Bring Your Own Container service (launched in 4.0) to show what’s possible when Arango’s Agentic AI Suite microservices are combined into a custom tool. Running against a semiconductor design dataset spanning 30 years of design evolution, Contextus finds relationships in a graph that nobody thought to query.
Point it at a starting node, and Contextus runs entity resolution, performs a multi-hop breadth-first traversal, and scores every node in the resulting subgraph using GraphSAGE embeddings trained from scratch on the graph’s own link structure — no external features or labels, just topology. It then surfaces the top-K highest-scoring connections that aren’t direct neighbors — what Daniel called “dark edges” — and narrates, in plain English, why each one might be worth a closer look. A “Direct” mode surfaces immediate neighbors instead, and a “Custom” mode lets users query in their own words. Under the hood, it’s a LangGraph ReAct agent chaining four tools: node lookup, graph traversal, link-strength prediction, and explanation — with optional evaluation layers (RAGAS, Phoenix) for teams that want to quantify result quality alongside the qualitative read.
From the Q&A
A few questions from the community stood out:
- Is it model- and infrastructure-agnostic? Yes — any LLM, including your own fine-tunes, and it works in air-gapped environments.
- Is GraphSAGE the only option? No. The team has experimented with graph attention networks, and given Contextus’s 30-year historical dataset, graph temporal networks are a natural next step for modeling how the data — and its relationships — evolve over time.
- How is data quality handled before ingestion? That’s AutoGraph’s job: a pre-processing pipeline handles deduplication and entity extraction before anything reaches the knowledge graph, with community summaries preserving contextual relevance across chunks and entities.
What’s next
Contextus is a proof point, not a product on the price list — Daniel and the solutions architecture team build tailored applications like it for customers exploring proofs of concept on Arango. If this sparked ideas for your own data, the team welcomes a conversation.
Looking ahead, Arango COO & CTPO Ravi Marwaha is hosting a webinar, How to Build Reliable, Context-Aware AI at Enterprise Scale, covering the six requirements for a persistent enterprise context layer: semantic clarity, graph-native relationships, temporal awareness, provenance and trust, AI-native services, and unified multimodel data.
This meetup series runs monthly. Have a topic you’d like to see covered? Reach out to Mark Milinkovich (mark.milinkovich@arango.ai) or share it with the community — and if you’d like to talk through what a graph-guided discovery agent could look like on your own data, Daniel’s on LinkedIn (@DBMorris) and happy to hear from you.
