Gemini Integration

Use ACE with Gemini or any HTTP-capable tool - REST API access to all 9 entity types

What You'll Build

Gemini with ACE's complete infrastructure

Connect Gemini to ACE's REST API for a complete memory and project management system:

Track All 9 Entity Types: Issues, Decisions, Work Logs, Architecture, Best Practices, Patterns, Tags, Relationships, Generic Memories

AI-Assisted Plan Builder: Generate complete project plans with all entities and relationships using your configured AI provider

Knowledge Graph: Create and traverse relationships between entities with interactive visualization

60+ REST Endpoints: Full API access for CRUD operations, search, bulk import, and graph queries

Universal Compatibility: Works with any tool that can make HTTP requests - Cursor, Lovable, GitHub Copilot, Aider, and more

How It Works:

Gemini (or your custom application) uses ACE's REST API to store and retrieve structured project data. All 9 entity types support full-text search, tagging, relationships, and semantic search with embeddings.

Prerequisites

What you'll need

Google Cloud Account

Get API access from Google AI Studio

ACE Account

View pricing - Free plan includes everything you need to get started

Python or JavaScript

We'll show examples in both languages

API Keys (Optional)

Configure OpenAI key for semantic search, or Google key for AI Builder. Learn about BYOK →

Integration Approaches

Works with any HTTP-capable tool

REST API Integration

Use ACE's REST API from any programming language or AI-powered IDE. Full access to all 60+ endpoints via standard HTTP requests.

⚙️ ACE Server URL

Where is your ACE server running?

💻 Local Development

Running ACE on your machine with ace start

http://localhost:7777

☁️ Cloud / On-Premises

ACE deployed to your infrastructure

https://ace.yourdomain.com

All tiers can run anywhere. Tiers only differ by limits (namespaces, members, memories).

💡 In the code examples below: Replace http://localhost:7777 with your server URL from above.

REST API Examples

Use ACE from any programming language or AI coding tool

Note: Replace {YOUR_NAMESPACE} with your namespace from the dashboard. These examples use localhost where ACE runs with ace start.

Create an Issue:

curl -X POST http://localhost:7777/api/v1/{YOUR_NAMESPACE}/issues \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Implement user authentication",
    "description": "Add JWT-based auth to API",
    "status": "open",
    "priority": "high",
    "tags": ["security", "backend"]
  }'

Log a Decision:

curl -X POST http://localhost:7777/api/v1/{YOUR_NAMESPACE}/decisions \
  -H "Content-Type: application/json" \
  -d '{
    "decision": "Use PostgreSQL for production database",
    "rationale": "Better performance, ACID compliance, and ecosystem",
    "alternatives": ["MySQL", "MongoDB"],
    "tags": ["architecture", "database"]
  }'

List and Filter Issues:

curl "http://localhost:7777/api/v1/{YOUR_NAMESPACE}/issues?status=open&limit=10"

These examples work with any tool that can execute bash commands (Cursor, Aider, Claude Code CLI, etc.)

💡 Optional: Environment Variables for Convenience

If you prefer, you can set an environment variable to avoid repeating your namespace:

export ACE_NAMESPACE="your-namespace"

Then use $ACE_NAMESPACE in commands:

curl http://localhost:7777/api/v1/$ACE_NAMESPACE/issues

AI-Assisted Plan Builder

Generate complete project plans with AI

Use ACE's AI Builder to automatically generate comprehensive project plans with all entities and relationships. Uses your configured AI provider and model from Dashboard Settings.

Generate a Complete Project Plan:

curl -X POST http://localhost:7777/api/v1/{YOUR_NAMESPACE}/plans/bulk \
  -H "Content-Type: application/json" \
  -d '{
    "project_name": "E-commerce Platform",
    "description": "Build a modern e-commerce platform with React, Node.js, and PostgreSQL"
  }'

Uses your default AI provider configured in Dashboard → Settings → AI Keys

What Gets Created:

Issues: Feature requirements, bugs to prevent, technical debt items
Architecture: System components, databases, APIs, infrastructure
Decisions: Technology choices with rationales and alternatives
Best Practices: Coding standards, security guidelines, performance tips
Patterns: Design patterns to follow, anti-patterns to avoid
Work Logs: Initial sprint planning and task breakdown
Relationships: All entities linked together in a knowledge graph

In seconds, you get a complete project plan with 50-100+ entities all linked in a knowledge graph

Knowledge Graph

Connect entities with relationships

Create relationships between entities to build a knowledge graph. ACE supports 10 relationship types.

Create a Relationship:

curl -X POST http://localhost:7777/api/v1/{YOUR_NAMESPACE}/relationships \
  -H "Content-Type: application/json" \
  -d '{
    "source_entity_type": "decision",
    "source_entity_id": 1,
    "target_entity_type": "architecture",
    "target_entity_id": 2,
    "relationship_type": "implements",
    "metadata": {"phase": "initial-setup"}
  }'

Traverse the Knowledge Graph:

curl "http://localhost:7777/api/v1/{YOUR_NAMESPACE}/relationships/traverse/decision/1"

10 Relationship Types:

• implements
• references
• supersedes
• relates_to
• caused_by
• resolves
• documented_in
• depends_on
• blocks
• duplicates

Use Cases

What you can build

Customer Support Bot

Gemini handles conversations, ACE remembers customer history, preferences, and past issues for personalized support.

Personal Assistant

Build a Gemini-powered assistant that remembers your schedule, preferences, habits, and important information.

Learning Companion

Track what you've learned, your progress, and adapt explanations based on your knowledge level stored in ACE.

Documentation Assistant

Gemini answers questions about your codebase, with ACE storing project structure, patterns, and decisions.

Best Practices

Tips for optimal performance

Use descriptive memory keys

Keys like "user_123_preferences" are better than "data_1" for semantic search

Limit context retrieval

Use limit=5-10 for recall to avoid overwhelming Gemini with context

Store conversation summaries

Instead of storing entire conversations, extract and store key points

Use namespaces for isolation

Separate namespaces for different users/projects prevent memory mixing

Troubleshooting

Common issues and fixes

Gemini not using context effectively

Try:

Make context more explicit in the prompt
Reduce context size (fewer, more relevant memories)
Format context as bullet points or numbered list
Add instructions like "Reference the context when answering"

API key errors

Verify:

Gemini API key is from Google AI Studio
ACE namespace exists and API key is valid
Both APIs are accessible from your network

Slow response times

Optimize by:

Reducing recall limit (try 3-5 instead of 10+)
Running ACE server locally for faster memory access
Caching frequent context queries
Using async/await properly for parallel operations