Firebase to Claude via MCP

[Detroit-ish]

Pre-submission Checklist

• I have verified that this discussion would not be more appropriate as an issue in a specific repository
• I have searched existing discussions to avoid duplicates

Discussion Topic

I am 100% lost on why this is not working. Runs in terminal and connect shows in Claude logs. The tools show in inspector. Yet, I cannot get Claude to have the tools show. [
claude_desktop_config.json

// src/index.ts
import * as dotenv from 'dotenv';
dotenv.config(); // Add this before any other code
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { initializeApp, cert } from "firebase-admin/app";
import { getFirestore } from "firebase-admin/firestore";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";

// Initialize Firebase Admin
const serviceAccount = process.env.FIREBASE_SERVICE_ACCOUNT;
if (!serviceAccount) {
  throw new Error("FIREBASE_SERVICE_ACCOUNT environment variable is required");
}

const app = initializeApp({
  credential: cert(JSON.parse(serviceAccount)),
});

const db = getFirestore(app);

// Schema Validation
const ReadDocumentSchema = z.object({
  collection: z.string(),
  document: z.string(),
});

const WriteDocumentSchema = z.object({
  collection: z.string(),
  document: z.string().optional(),
  data: z.record(z.any()),
});

// Create server instance
const server = new Server(
  {
    name: "firebase",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// List available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "read-document",
        description: "Read a document from Firestore",
        inputSchema: {
          type: "object",
          properties: {
            collection: {
              type: "string",
              description: "Collection name to read from",
            },
            document: {
              type: "string",
              description: "Document ID to read",
            },
          },
          required: ["collection", "document"],
        },
      },
      {
        name: "write-document",
        description: "Write a document to Firestore",
        inputSchema: {
          type: "object",
          properties: {
            collection: {
              type: "string",
              description: "Collection name to write to",
            },
            document: {
              type: "string",
              description: "Optional document ID (auto-generated if not provided)",
            },
            data: {
              type: "object",
              description: "Data to write to the document",
            },
          },
          required: ["collection", "data"],
        },
      },
    ],
  };
});

// Handle tool execution
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    if (name === "read-document") {
      const { collection, document } = ReadDocumentSchema.parse(args);
      
      const docRef = db.collection(collection).doc(document);
      const docSnap = await docRef.get();

      if (!docSnap.exists) {
        return {
          content: [
            {
              type: "text",
              text: `Document ${document} not found in collection ${collection}`,
            },
          ],
        };
      }

      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(docSnap.data(), null, 2),
          },
        ],
      };
    }

    if (name === "write-document") {
      const { collection, document, data } = WriteDocumentSchema.parse(args);
      
      let docRef;
      if (document) {
        // Use provided document ID
        docRef = db.collection(collection).doc(document);
        await docRef.set(data);
      } else {
        // Auto-generate document ID
        docRef = await db.collection(collection).add(data);
      }

      return {
        content: [
          {
            type: "text",
            text: `Successfully wrote document with ID: ${docRef.id}`,
          },
        ],
      };
    }

    throw new Error(`Unknown tool: ${name}`);
  } catch (error) {
    if (error instanceof z.ZodError) {
      throw new Error(
        `Invalid arguments: ${error.errors
          .map((e) => `${e.path.join(".")}: ${e.message}`)
          .join(", ")}`
      );
    }
    throw error;
  }
});

// Start the server
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Firebase MCP Server running on stdio");
}

main().catch((error) => {
  console.error("Fatal error:", error);
  process.exit(1);
});

[jspahrsummers]

Can you share what behavior you are seeing?