Firebase Firestore

Firebase (Google)OfficialCreated by Google LLCDistributed by Firebase (Google)

Skill
Tool integration
Data and AI
Apache-2.0
Low risk

From the author

Sets up, manages, queries, and configures Cloud Firestore databases (Standard/Enterprise edition), including data modeling, security rules, indexes, and SDK integrations (Web, Admin, Python, iOS, Android, Flutter). Use when adding or migrating app databases, creating/listing Firestore databases, defining data models/indexes, writing SDK queries, or integrating Firestore SDKs. For authoring or modifying Firestore Security Rules (firestore.rules), delegate to the firestore-rules-author subagent if subagent delegation is available, or use firestore-rules-creation otherwise. Don't use for Data Connect, BigQuery, or standalone Hosting, Auth, Storage/GCS, Crashlytics, or Functions tasks.

— the description by Google LLC

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a comprehensive framework for interacting with Google Cloud Firestore. It guides users through the lifecycle of a Firestore database, including instance provisioning, edition selection (Standard vs. Enterprise), data modeling, index management, and SDK integration across multiple platforms like Web, Android, iOS, and Flutter. It emphasizes architectural best practices, such as mandatory reference reading for SDK usage and proper security rule deployment.

What it does

Lists and inspects existing Firestore database instances.
Provisions new Firestore databases with specific edition and location settings.
Provides structured guidance for data modeling using documents, collections, and subcollections.
Facilitates SDK integration by providing platform-specific setup and initialization patterns.
Manages database indexes and security rule deployment workflows.
Enforces mandatory architectural checks before application code implementation.

When to use it

When setting up a new Cloud Firestore database for an application.
When migrating existing data or configuring database indexes.
When integrating Firestore SDKs into Web, Android, iOS, or Flutter projects.
When defining or updating data models for a NoSQL document-oriented structure.
When troubleshooting or verifying database instance editions and configurations.

Advantages

Ensures consistent database provisioning and configuration across environments.
Provides clear paths for both Standard and Enterprise edition workflows.
Promotes secure development practices by mandating security rule management.
Reduces errors by requiring verification of SDK versions and architectural patterns.

Usage examples

“List all my current Firestore databases and their editions.”: The agent will execute the list command and provide a summary of all database IDs and their respective editions.
“I need to set up a new Firestore database in the us-central1 region.”: The agent will guide you through creating an Enterprise edition database in the specified location.
“How do I query across all subcollections with the same name?”: The agent will explain the concept of collection group queries and provide the necessary syntax for your platform.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/firebase/firebase-firestore/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip firebase-firestore.zip -d .agents/skills

Documentation by Google LLC

Cloud Firestore Database and Operations

[!IMPORTANT] Security Rules Authoring (firestore.rules) Whenever setting up a Firestore-backed app or creating/modifying firestore.rules, configure "firestore": { "rules": "firestore.rules" } in firebase.json and deploy firestore.rules (npx -y firebase-tools@latest deploy --only firestore:rules), even if server routes use the Admin SDK:
If subagent delegation AND the firestore-rules-author subagent are available: delegate authoring firestore.rules to the firestore-rules-author subagent rather than writing firestore.rules directly in the main agent.
If subagent delegation is unavailable (e.g., subagents not enabled in the IDE) OR firestore-rules-author is not installed: read and follow the firestore-rules-creation skill to write firestore.rules directly.

Before setting up dependencies, writing data models, or configuring security rules, you MUST always identify the Firestore instance edition.

1. Instance Selection and Edition Detection

Run the following command to list current Firestore databases:

npx -y firebase-tools@latest firestore:databases:list

A. Instance Found

For each database found, inspect its edition and details:

npx -y firebase-tools@latest firestore:databases:get <database-id>

Ask the user which database instance they wish to target or if they would prefer to create a new instance.
Once the target instance is established:
- If the edition is STANDARD, follow the guides under references/standard/.
- If the edition is ENTERPRISE or native mode, follow the guides under references/enterprise/.

B. No Instance Found (or New Requested)

If no databases exist or the user requests a new one, default to provisioning an Enterprise edition database and ask the user what location to use. Run npx -y firebase-tools@latest firestore:locations to get the list of options. Suggest colocating with other resources if applicable.

Once the location is determined, create the database:

npx -y firebase-tools@latest firestore:databases:create <database-id> --edition="enterprise" --location="<selected-location>"

Proceed with using the guides under references/enterprise/.

2. Specialized Guides

Based on the identified or created instance edition, open and read the corresponding reference guides:

Standard Edition (`references/standard/`)

Provisioning: Read provisioning.md
Security Rules: See the firestore-rules-creation skill
SDK Usage: Read web_sdk_usage.md, android_sdk_usage.md, ios_setup.md, or flutter_setup.md
Indexes: Read indexes.md

Enterprise Edition / Native Mode (`references/enterprise/`)

Provisioning: Read provisioning.md
Data Model: Read data_model.md
Security Rules: See the firestore-rules-creation skill
SDK Usage:
[!CRITICAL] Mandatory Reference Reading Before writing or modifying any application code for Firestore Enterprise Edition, you MUST read at least one of the relevant reference documents below for the target platform/language to understand specific architectural requirements and pipeline initialization patterns.
Read web_sdk_usage.md, python_sdk_usage.md, android_sdk_usage.md, ios_setup.md, or flutter_setup.md
Indexes: Read indexes.md

Files

ATTRIBUTION.mdAdded by AutoGineer966 B
LICENSELicence file added by AutoGineer11.1 KiB
SKILL.md4.9 KiB
references/enterprise/android_sdk_usage.md9.7 KiB
references/enterprise/data_model.md2.8 KiB
references/enterprise/flutter_setup.md4.6 KiB
references/enterprise/indexes.md3.9 KiB
references/enterprise/ios_setup.md5.8 KiB
references/enterprise/provisioning.md3.2 KiB
references/enterprise/python_sdk_usage.md3.0 KiB
references/enterprise/web_sdk_usage.md4.6 KiB
references/standard/android_sdk_usage.md6.6 KiB
references/standard/flutter_setup.md4.5 KiB
references/standard/indexes.md3.4 KiB
references/standard/ios_setup.md5.3 KiB
references/standard/provisioning.md2.8 KiB
references/standard/web_sdk_usage.md4.4 KiB

references/standard/indexes.md

Firestore Indexes Reference

Indexes allow Firestore to ensure that query performance depends on the size of the result set, not the size of the database.

Index Types

Single-Field Indexes

In Standard Edition, Firestore automatically creates a single-field index for every field in a document (and subfields in maps). * Support: Simple equality queries (==) and single-field range/sort queries (<, <=, orderBy). * Behavior: You generally don't need to manage these unless you want to exempt a field.

Composite Indexes

A composite index stores a sorted mapping of all documents based on an ordered list of fields. * Support: Complex queries that filter or sort by multiple fields. * Creation: These are NOT automatically created. You must define them manually or via the console/CLI.

Automatic vs. Manual Management

What is Automatic?

Indexes for simple queries.
Merging of single-field indexes for multiple equality filters (e.g., where("state", "==", "CA").where("country", "==", "USA")).

When Do I Need to Act?

If you attempt a query that requires a composite index, the SDK will throw an error containing a direct link to the Firebase Console to create that specific index.

Example Error:

"The query requires an index. You can create it here: https://console.firebase.google.com/project/..."

Query Support Examples

Simple Equality: where("a", "==", 1)
- Index Required: Automatic (Single-Field)
Simple Range/Sort: where("a", ">", 1).orderBy("a")
- Index Required: Automatic (Single-Field)
Multiple Equality: where("a", "==", 1).where("b", "==", 2)
- Index Required: Automatic (Merged Single-Field)
Equality + Range/Sort: where("a", "==", 1).where("b", ">", 2)
- Index Required: Composite Index
Multiple Ranges: where("a", ">", 1).where("b", ">", 2)
- Index Required: Composite Index (limited query support)
Array Contains + Equality: where("tags", "array-contains", "news").where("active", "==", true)
- Index Required: Composite Index

Best Practices & Exemptions

You can exempt fields from automatic indexing to save storage or strictly enforce write limits.

1. High Write Rates (Sequential Values)

Problem: Indexing fields that increase sequentially (like timestamp) limits the write rate to ~500 writes/second per collection.
Solution: If you don't query on this field, exempt it from simple indexing.

2. Large String/Map/Array Fields

Problem: Indexing limits (40k entries per doc). Indexing large blobs wastes storage.
Solution: Exempt large text blobs or huge arrays if they aren't used for filtering.

3. TTL Fields

Problem: TTL (Time-To-Live) deletion can cause index churn.
Solution: Exempt the TTL timestamp field from indexing if you don't query it.

Management

Config files

Your indexes should be defined in firestore.indexes.json (pointed to by firebase.json).

{
  "indexes": [
    {
      "collectionGroup": "cities",
      "queryScope": "COLLECTION",
      "fields": [
        { "fieldPath": "country", "order": "ASCENDING" },
        { "fieldPath": "population", "order": "DESCENDING" }
      ]
    }
  ],
  "fieldOverrides": []
}

CLI Commands

Deploy indexes only:

npx -y firebase-tools@latest deploy --only firestore:indexes

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Node.js

The author says: This skill is best used with the Firebase CLI, but does not require it. Firebase CLI can be accessed through `npx -y firebase-tools@latest`.

Security

What our scanner noticed· Low risk

Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Google LLC

Publisher

Firebase (Google) (Official)

Distributed by

Firebase (Google)

Source

firebase/agent-skills · skills/firebase-firestore · commit b76be96

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by Google LLC or Firebase (Google).

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download firebase-firestore.zip