Dash

The future is personal agents, and Dash is one. It gives you an AI assistant that books restaurants, orders food, and manages communications by filtering spam and prioritizing urgent messages.

Comment

Inspiration

In today's digital world, we're drowning in information across dozens of platforms while juggling countless tasks. What if everyone had their own personal AI agent - not just another chatbot, but a truly personalized assistant that remembers everything about you, learns your preferences, and takes meaningful actions on your behalf? Dash was born from this vision of AI that works for you, understands you, and evolves with you - creating a future where personal agents transform how we interact with technology and manage our digital lives.

What it does

Dash provides each user with their own personalized AI agent with powerful capabilities:

  • Personalized Memory & Understanding: Each agent maintains a persistent memory of user preferences and past interactions using a private knowledge graph database.

  • Intelligent Communication Management: Dash monitors incoming messages across email, WhatsApp, and Slack, automatically categorizing them as spam, important, or urgent, and sending appropriate notifications.

  • Action-Taking Capabilities: Agents can perform tasks through integrated services, such as booking restaurants through Dineout, ordering food from delivery services, and sending emails (with draft confirmation).

Note: Currently, all API integrations (WhatsApp, Slack, email, Dineout, food ordering) are implemented as mock services for development purposes, not connected to real external APIs.

How I built it

  • Frontend: A React application with Material UI that provides user interaction (currently in progress, planned for future implementation).

  • Agent Framework: Core intelligence uses LangChain and LangGraph to orchestrate complex reasoning flows, allowing the agent to determine when to query databases and when to take actions.

  • Knowledge Storage: I implemented ArangoDB as a graph database, with each user getting their own private database (user_{user_id}) alongside access to a shared, read-only common_db. This architecture provides a secure way to have multiple users while ensuring they can't access each other's data.

  • Consumer Agents: Specialized Celery-based agents monitor external message sources, using LLMs to extract relevant identifiers and update the knowledge graph. These agents also analyze messages to classify them as spam, important, or urgent, sending appropriate notifications to users. In the future, these agents will be enhanced to provide deeper insights from communications.

Challenges I ran into

  1. How to have ArangoDB database sharing by all users while maintaining data privacy
    • Solution: Created a private database and user in ArangoDB for each Dash user. Like password hashes, I store these DB credentials in the _system database which only my backend can access. Additionally, I have a common database with read access for everyone containing restaurant data, dishes, prices, and ratings.
  2. Limited support for defining custom nodes and edges when importing data
    • Solution: Wrote a custom importer with parallelization to import exponentially faster while maintaining proper node types and connections.
  3. Lack of resources for low-level design of personal agent systems
    • Solution: After creative thinking, developed a design using LangChain, LangGraph, and Celery. Determined which prompts work effectively and how a personal agent should be implemented to be flexible for extensions and scalable, by having separate agents for each purpose with backend processing using Celery.
  4. UI development challenges as a backend developer
  5. Finding the most cost-effective and scalable agent implementation
    • Solution: Kept prompts concise and removed unnecessary LLM calls. Modified ArangoGraphQAChain to support turning off LLM QA generation from data when only raw AQL query output is needed.
  6. Running LLM-generated code securely and efficiently
    • Solution: Implemented a sandbox execution environment using Docker with Jupyter notebooks, with one cell loading the database into NetworkX and another cell for model-generated code.
  7. Limiting events and tools to the user level
    • Solution: Implemented a factory design pattern where all tools and agents are generated for each user based on user ID, providing access only to that user's private database.

  8. Unexpected unknown error while importing ArangoDB graph into NetworkX

    G_adb = nxadb.Graph(name="restaurants", db=db)

    /usr/local/lib/python3.11/dist-packages/nx_arangodb/classes/graph.py in __set_arangodb_backend_config(self)
    307 
    308     def __set_arangodb_backend_config(self) -> None:
--> 309        config = nx.config.backends.arangodb
    310        config.use_gpu = True  # Only used by default if nx-cugraph is available

AttributeError: 'Config' object has no attribute 'arangodb'
    • Solution: Implemented a custom ArangoDB to NetworkX importer load_arangodb_graph_to_networkx.py

  9. Problem: Since text_to_nx_algorithm_to_text in the template was not working in most cases and there was no code corrector implemented.

    • Solution: I created a custom ArangoNetworkxQAChain.

Accomplishments that I'm proud of

I'm proud of my creative problem-solving approach, finding innovative solutions to challenging technical problems. From database isolation techniques to secure code execution, I've developed a robust architecture that separates user data while maintaining shared knowledge. My optimization of LLM usage and custom importers demonstrates my commitment to building not just a functional system, but one that can scale efficiently.

What I learned

Through developing Dash, I gained deep expertise in agentic frameworks like LangChain and LangGraph, effective prompt engineering techniques, and UI development basics. Most importantly, I discovered the power of ArangoDB as a graph database solution, which has become my favorite database technology for its flexibility and performance in knowledge graph applications.

What's next for Dash

I plan to continue development during weekends and free time, focusing on implementing the UI, improving various tools, and exploring different approaches to writing agents. My goal is to steadily enhance Dash's capabilities while maintaining its core vision of providing truly personal AI agents that understand and act according to each user's unique needs and preferences.

Built With

Share this project:

Updates