Automodeler

Drop a CSV into AutoModeler and get an active database you can chat with. It autonomously handles infrastructure, data cleaning, vector RAG search, and automated machine learning. No code required.

Comment

Inspiration

Suppose you want to build a cool AI data project. You quickly realize you are spending 80% of your time just cleaning a messy CSV, figuring out data types, and setting up database infrastructure. The biggest barrier to AI data apps isn't the AI - it's the massive amount of manual engineering required to get data ready.

We built AutoModeler to completely skip that step by creating an autonomous ecosystem where AI agents take over the entire pipeline.

What it does

You drop a raw CSV into our frontend, and an ensemble of specialized AI agents takes over :

  • The Profiler Agent : analyses your data, infers SQL types, and generates exploratory charts.

  • The Schema Architect Agent : synthesises optimised SQL schemas and vector indexes via an LLM.

  • The Provisioner Loop : instantly spins up a brand new CockroachDB Serverless database on the fly using the ccloud CLI.

  • The Self-Tuning Optimizer Agent : acts like a DBA. It runs EXPLAIN query plans, detects slow full-table scans, and writes its own CREATE INDEX statements autonomously.

  • The Interactive Agent Layer : gives you an interface to chat with your data using semantic RAG, or task an AutoML agent with iteratively training and refining scikit-learn machine learning models.

How we built it

  • Backend: AWS Lambda using a custom Docker container, triggered asynchronously by Amazon S3 uploads.

  • Database & Memory: CockroachDB Serverless. It stores both our strict relational data and high-dimensional embeddings in one place, using its native VECTOR(768) columns and the <-> KNN operator for RAG.

  • AI Layer: We used Groq (Llama-3.3-70b) for fast schema generation and chat. For the heavy reasoning loops, we used OpenRouter (Nemotron). We built our custom agent architecture to function conceptually like an MCP (Model Context Protocol) implementation by giving it tools to dynamically interact with and modify its database environment.

  • Frontend: Hosted on AWS Amplify.

Challenges we ran into

  • Execution Loop vs. Lambda Limits: Cramming heavy libraries (torch, scikit-learn) into a serverless container was a nightmare. Because our agents run an iterative code-execution loop, we had to cap processing at 500 rows to avoid hitting Lambda's 15-minute timeout and Out-Of-Memory errors.

  • API Throttling from Heavy Agent Traffic: Because agents make multiple iterative calls to fix their own code mistakes, we constantly triggered brutal free-tier rate limits on Groq and OpenRouter. We had to build aggressive back-off timers so the pipeline wouldn't crash mid-run.

  • Statelessness: Lambda forgets everything instantly. We had to use S3 to store an agent_memory_state.txt connection file so our agents could actually find the newly created database between separate execution steps.

Accomplishments that we're proud of

  • True Agentic Database Tuning: Building an optimiser that doesn't just generate text, but acts like an autonomous DBA by analysing performance metrics and dynamically deploying its own indexing DDL.

  • Autonomous Infrastructure: Automating the CockroachDB CLI inside a serverless function to spin up isolated, real infrastructure purely from an S3 file upload event felt like magic.

What we learned

  • Zero to One with AWS: Before this hackathon, we had basically zero experience deploying onto AWS. It was a massive learning curve, but now we actually know how to package a heavy application into a custom Docker image, push it to ECR, deploy it as a serverless container on Lambda, and hook up S3 event triggers.

  • Vector Mechanics: We learned a ton about distributed SQL and how to use the <-> operator for fast vector similarity searches directly inside CockroachDB.

  • Code Prompting is Hard: Designing prompts for autonomous code execution is incredibly difficult. If you don't give the agent strict structural rules and data profiles as context, the generated code immediately crashes.

What's next for Automodeler

  • Agentic Session Flashbacks: Saving compressed summaries of previous chat logs and code iterations to S3. This lets us re-hydrate the agent's exact context on a fresh serverless call without burning through our free-tier token limits on long chat histories.

  • Secure Sandbox: Moving the AutoML agent away from raw Python exec() commands and into a formal, sandboxed container for safe code execution.

Built With

Share this project:

Updates

Submission history