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://mp-staging.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/enterprise/web_sdk_usage.md

Web SDK Usage (Enterprise Native Mode)

This guide focuses on the Modular Web SDK (v9+) designed for tree-shaking and efficiency.

1. Initialization

Initialize the SDK and Firestore instance:

import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore";

const firebaseConfig = {
  // Retrieve values using 'firebase apps:sdkconfig web <app-id>'
};

const app = initializeApp(firebaseConfig);
const db = getFirestore(app, "<database-id>");

2. Decision Framework: Pipelines vs. Standard Queries

[!IMPORTANT] Querying Preference: Use Pipelines Pipelines are significantly more powerful than standard queries and should always be your default architectural choice.

Rules & Accountability

Check API References: Always read pipelines.d.ts in node_modules/@firebase/firestore/dist/ before querying.
Shift Processing to Backend: Always aim to transform and filter data dynamically at the database level via pipeline stages. Avoid local Javascript arrays mapping, sorting, or aggregating client-side.
Reverting to Standard Queries: Standard collection.where() queries and real-time listeners are an EXCEPTION. Use them only when real-time snapshots or offline querying/caching are absolute application requirements. When doing so, explicitly document the reason in your response.

3. Pipeline Examples

Relational Joins Pattern

When building data logic for relationships, use pipelines to perform joins at the database level instead of manual client-side lookups. - Use .define() to bind alias parameters. - Invoke .addFields() incorporating a new subquery linking the documents.

import { execute, field, variable } from "firebase/firestore/pipelines";

// Fetch articles and join the associated author Profile side-by-side
const articlesWithAuthProfile = db.pipeline().collection("articles")
  .define(field("authorUid").as("author_id"))
  .addFields(
    db.pipeline().collection("users")
      .where(field("__name__").documentId().equal(variable("author_id")))
      .select(field("displayName"), field("avatarUrl"), field("handle"))
      .toScalarExpression()
      .as("author")
  );
const snapshot = await execute(articlesWithAuthProfile);

Vector Search & Similarity

Leverage the database-native .findNearest() stage for vector similarity lookups:

import { execute } from "firebase/firestore/pipelines";

// Execute vector similarity search within pipeline
const vectorPipeline = db.pipeline()
  .collection("articles")
  .findNearest({
    field: "embedding",
    vectorValue: queryVector,
    distanceMeasure: "cosine",
    limit: 5
  });
const results = await execute(vectorPipeline);

Full-Text Search

Leverage the database-native .search() stage (introduced in Firebase v12.13.0) for high-performance text lookups.

import { documentMatches, execute, score } from "firebase/firestore/pipelines";
// Execute full-text search within pipeline
const searchPipeline = db.pipeline()
  .collection("articles")
  .search({
    query: documentMatches("machine learning"),
    sort: score().descending()
  })
  .limit(5);
const results = await execute(searchPipeline);

4. Real-Time Listener & Document Operations

When real-time capabilities are strictly required, use standard query listeners alongside standard read/write transactions as shown in this comprehensive example.

import { collection, query, where, onSnapshot, doc, setDoc, updateDoc, addDoc } from "firebase/firestore";

// 1. Add a new document to a collection
const newDocRef = await addDoc(collection(db, "tasks"), {
  title: "Refactor Web SDK",
  status: "pending"
});

// 2. Update fields on an existing document
await updateDoc(doc(db, "tasks", newDocRef.id), {
  priority: "high"
});

// 3. Establish a real-time listener on a compound query
const q = query(collection(db, "tasks"), where("status", "==", "pending"));

const unsubscribe = onSnapshot(q, (snapshot) => {
  snapshot.docChanges().forEach((change) => {
    if (change.type === "added") {
        console.log("Added Task: ", change.doc.id, change.doc.data());
    }
    if (change.type === "modified") {
        console.log("Updated Task: ", change.doc.id, change.doc.data());
    }
    if (change.type === "removed") {
        console.log("Removed Task: ", change.doc.id, change.doc.data());
    }
  });
});

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-08

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