Connecting it with Gemini

In the dynamic world of software development, efficiency and automation are paramount. Custom Command Line Interfaces (CLIs) can transform complex workflows into simple, rapid operations. When you combine this power with an AI coding assistant like Gemini, the possibilities for streamlined development are endless.

This article will guide you through the process of creating a custom CLI to interact with the Google Analytics Data API, and then demonstrate how to integrate it with Gemini for a truly frictionless development experience.

1. Building a Google Analytics CLI

To begin, I'll construct a Python-based CLI for Google Analytics. Please note: The code snippets provided in this article are illustrative samples, not complete or directly executable solutions. They are intended for conceptual understanding and reference only. I'll leverage Python's standard argparse library for command-line argument parsing.

1.1. Core Commands

I define the following commands using argparse. These snippets are conceptual examples and not intended for direct copy-pasting or execution.

import argparse
import sys
# Simplified placeholder functions
def list_account_summaries():
    print("Executing list-account-summaries (Placeholder)")
def run_ga4_report(property_id, metrics, dimensions, start_date, end_date):
    print(f"Executing GA4 report for property {property_id} (Placeholder)")
def real_time_report(property_id):
    print(f"Executing real-time report for property {property_id} (Placeholder)")
# ... (other placeholder functions like set_default_property, show_default_property, clear_default_property)
def interactive_mode():
    print("Entering interactive mode. Type 'help' for commands, 'exit' to quit.")
    while True:
        try:
            command_line = input("mcp> ").strip()
            # ... (simplified interactive parsing logic, e.g., only handling 'exit')
            if command_line.lower() == "exit":
                break
            # ...
        except EOFError:
            print("\nExiting interactive mode.")
            break
        # ...
def main():
    parser = argparse.ArgumentParser(description="CLI for Google Analytics Data API operations.")
    subparsers = parser.add_subparsers(dest="command", help="Available commands")
    # Command: list-account-summaries
    list_accounts_parser = subparsers.add_parser(
        "list-account-summaries", help="Lists summaries of Google Analytics accounts."
    )
    list_accounts_parser.set_defaults(func=list_account_summaries)
    # Command: run-ga4-report
    run_report_parser = subparsers.add_parser(
        "run-ga4-report", help="Executes GA4 reports."
    )
    run_report_parser.add_argument("--property-id", type=str, required=True, help="Google Analytics Property ID.")
    run_report_parser.add_argument("--metrics", nargs="+", required=True, help="Metrics to request (e.g., activeUsers sessions).")
    # ... (other arguments omitted for brevity)
    run_report_parser.set_defaults(
        func=lambda args: run_ga4_report(
            args.property_id, args.metrics, None, None, None # Simplified for non-functionality
        )
    )
    # ... (other command definitions omitted for brevity)
    args = parser.parse_args()
    if args.command:
        args.func(args)
    else:
        interactive_mode()
if __name__ == "__main__":
    main()

• list-account-summaries: Lists summaries of all accessible Google Analytics accounts.
• run-ga4-report: Executes a Google Analytics 4 report, requiring a property-id, metrics, and optionally dimensions, start-date, and end-date.
• real-time: Retrieves real-time data for a specified property.
• set-default-property <ID>: Stores a Google Analytics Property ID as the default for subsequent commands.
• show-default-property: Displays the currently configured default Property ID.
• clear-default-property: Removes the stored default Property ID.

Note: For actual API interaction, you would integrate a library like google-analytics-data and use proper authentication within these functions. The code above provides a structural foundation.

1.2. Interactive Mode

To enhance the user experience, I've implemented an interactive mode. If the user executes the CLI without any arguments, it enters a loop where commands can be typed directly. This is particularly useful for exploring CLI functionalities without repeatedly typing the full command and python your_cli_ga.py prefix.

To enter interactive mode, simply run:

python your_ga_cli.py

Once inside, you'll see a prompt like this:

mcp> list-account-summaries

1.3. Enhancing User Experience (UX)

To make the CLI even more user-friendly, I incorporated two key UX improvements:

• Formatted Output: For commands returning tabular data (like reports), we recommend using a library such as tabulate to present results in a clean, readable table format. This significantly improves data comprehension.
• Default Property Management: I've introduced a configuration system (e.g., using a file like mcp_config.json) that allows users to set a default property_id. This eliminates the need to specify the property ID with every command, streamlining daily operations.

1.4. Executing the CLI

You can execute commands directly from your terminal:

python your_ga_cli.py run-ga4-report \
  --property-id [YOUR_PROPERTY_ID] \
  --metrics [METRIC_1] [METRIC_2] \
  --dimensions [DIMENSION_1] [DIMENSION_2] \
  # ... (other arguments as needed for your report)

2. Gemini Integration: Your AI Coding Assistant

Once my CLI was operational, the next crucial step was integrating it with Gemini. Gemini is an AI-powered coding assistant that can significantly aid in writing code, debugging, and automating tasks by understanding context and providing intelligent suggestions. For Gemini to effectively interact with my custom CLI and the underlying Google Analytics tools, proper authentication setup is essential.

2.1. Authentication and Credential Setup

The key to enabling Gemini's seamless interaction with Google Analytics tools lies in generating and correctly placing authorized_user credentials.

Here are the steps I followed:

1. Obtain OAuth Client Configuration: First, retrieve the OAuth client JSON file from the Google Cloud Console. This file is generated when you create a new OAuth client ID.
2. Generate authorized_user Credentials: I used the gcloud auth application-default login command to generate the authorized_user credentials. This command initiates an authentication flow in your browser; upon successful completion, it generates a JSON file containing the necessary credentials.

gcloud auth application-default login \

--scopes [REQUIRED_SCOPES_HERE] \

--client-id-file=/path/to/your/oauth_client_config.json

• Note: Replace /path/to/your/oauth_client_config.json with the actual path to your OAuth client configuration file. The -scopes argument ensures the generated credentials have the necessary permissions to read Google Analytics data and interact with Google Cloud services.

1. Verify Generated Credentials: The generated JSON file should contain a refresh_token and include the "type": "authorized_user" field. This confirms it's the correct type of credential for Gemini's integrated tools.
2. Place Credentials in Expected Location: Copy the content of the generated credentials file to the location that Gemini expects: /Users/gonzalogalante/.gemini/credentials.json.

Once these steps are completed, Gemini's integrated tools for Google Analytics will function seamlessly, providing intelligent assistance directly within your development environment.

3. Conclusion

Creating a custom CLI to interact with an API like Google Analytics might initially seem daunting. However, with the right tools and a structured approach, it becomes a relatively straightforward process.

The real magic unfolds when you combine your custom CLI with an AI coding assistant such as Gemini. The ability to automate tasks, debug issues, and receive contextual help directly within your terminal is a game-changer for any developer.

If you're looking to elevate your productivity, we highly encourage you to explore building your own CLIs and integrating them with Gemini. You'll unlock new levels of efficiency and innovation.