meta-ads-mcp 0.6.0__tar.gz → 0.7.1__tar.gz

{meta_ads_mcp-0.6.0 → meta_ads_mcp-0.7.1}/.gitignore

@@ -29,4 +29,5 @@ debug/
 # Keep organized directories but exclude some debug content
 !debug/README.md
 
-internal/
+internal/
+uv.lock

{meta_ads_mcp-0.6.0 → meta_ads_mcp-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-ads-mcp
-Version: 0.6.0
+Version: 0.7.1
 Summary: Model Context Protocol (MCP) plugin for interacting with Meta Ads API
 Project-URL: Homepage, https://github.com/pipeboard-co/meta-ads-mcp
 Project-URL: Bug Tracker, https://github.com/pipeboard-co/meta-ads-mcp/issues
@@ -331,6 +331,54 @@ For local installation configuration, authentication options, and advanced techn
       - `access_token` (optional): Meta API access token.
     - Returns: JSON string with the ID of the created budget schedule or an error message.
 
+22. `mcp_meta_ads_search_interests`
+    - Search for interest targeting options by keyword
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `query`: Search term for interests (e.g., "baseball", "cooking", "travel")
+      - `limit`: Maximum number of results to return (default: 25)
+    - Returns: Interest data with id, name, audience_size, and path fields
+
+23. `mcp_meta_ads_get_interest_suggestions`
+    - Get interest suggestions based on existing interests
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `interest_list`: List of interest names to get suggestions for (e.g., ["Basketball", "Soccer"])
+      - `limit`: Maximum number of suggestions to return (default: 25)
+    - Returns: Suggested interests with id, name, audience_size, and description fields
+
+24. `mcp_meta_ads_validate_interests`
+    - Validate interest names or IDs for targeting
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `interest_list`: List of interest names to validate (e.g., ["Japan", "Basketball"])
+      - `interest_fbid_list`: List of interest IDs to validate (e.g., ["6003700426513"])
+    - Returns: Validation results showing valid status and audience_size for each interest
+
+25. `mcp_meta_ads_search_behaviors`
+    - Get all available behavior targeting options
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `limit`: Maximum number of results to return (default: 50)
+    - Returns: Behavior targeting options with id, name, audience_size bounds, path, and description
+
+26. `mcp_meta_ads_search_demographics`
+    - Get demographic targeting options
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `demographic_class`: Type of demographics ('demographics', 'life_events', 'industries', 'income', 'family_statuses', 'user_device', 'user_os')
+      - `limit`: Maximum number of results to return (default: 50)
+    - Returns: Demographic targeting options with id, name, audience_size bounds, path, and description
+
+27. `mcp_meta_ads_search_geo_locations`
+    - Search for geographic targeting locations
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `query`: Search term for locations (e.g., "New York", "California", "Japan")
+      - `location_types`: Types of locations to search (['country', 'region', 'city', 'zip', 'geo_market', 'electoral_district'])
+      - `limit`: Maximum number of results to return (default: 25)
+    - Returns: Location data with key, name, type, and geographic hierarchy information
+
 ## Privacy and Security
 
 Meta Ads MCP follows security best practices with secure token management and automatic authentication handling. 

{meta_ads_mcp-0.6.0 → meta_ads_mcp-0.7.1}/README.md

@@ -306,6 +306,54 @@ For local installation configuration, authentication options, and advanced techn
       - `access_token` (optional): Meta API access token.
     - Returns: JSON string with the ID of the created budget schedule or an error message.
 
+22. `mcp_meta_ads_search_interests`
+    - Search for interest targeting options by keyword
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `query`: Search term for interests (e.g., "baseball", "cooking", "travel")
+      - `limit`: Maximum number of results to return (default: 25)
+    - Returns: Interest data with id, name, audience_size, and path fields
+
+23. `mcp_meta_ads_get_interest_suggestions`
+    - Get interest suggestions based on existing interests
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `interest_list`: List of interest names to get suggestions for (e.g., ["Basketball", "Soccer"])
+      - `limit`: Maximum number of suggestions to return (default: 25)
+    - Returns: Suggested interests with id, name, audience_size, and description fields
+
+24. `mcp_meta_ads_validate_interests`
+    - Validate interest names or IDs for targeting
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `interest_list`: List of interest names to validate (e.g., ["Japan", "Basketball"])
+      - `interest_fbid_list`: List of interest IDs to validate (e.g., ["6003700426513"])
+    - Returns: Validation results showing valid status and audience_size for each interest
+
+25. `mcp_meta_ads_search_behaviors`
+    - Get all available behavior targeting options
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `limit`: Maximum number of results to return (default: 50)
+    - Returns: Behavior targeting options with id, name, audience_size bounds, path, and description
+
+26. `mcp_meta_ads_search_demographics`
+    - Get demographic targeting options
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `demographic_class`: Type of demographics ('demographics', 'life_events', 'industries', 'income', 'family_statuses', 'user_device', 'user_os')
+      - `limit`: Maximum number of results to return (default: 50)
+    - Returns: Demographic targeting options with id, name, audience_size bounds, path, and description
+
+27. `mcp_meta_ads_search_geo_locations`
+    - Search for geographic targeting locations
+    - Inputs:
+      - `access_token` (optional): Meta API access token (will use cached token if not provided)
+      - `query`: Search term for locations (e.g., "New York", "California", "Japan")
+      - `location_types`: Types of locations to search (['country', 'region', 'city', 'zip', 'geo_market', 'electoral_district'])
+      - `limit`: Maximum number of results to return (default: 25)
+    - Returns: Location data with key, name, type, and geographic hierarchy information
+
 ## Privacy and Security
 
 Meta Ads MCP follows security best practices with secure token management and automatic authentication handling. 

{meta_ads_mcp-0.6.0 → meta_ads_mcp-0.7.1}/meta_ads_mcp/__init__.py

@@ -7,7 +7,7 @@ with the Claude LLM.
 
 from meta_ads_mcp.core.server import main
 
-__version__ = "0.6.0"
+__version__ = "0.7.1"
 
 __all__ = [
     'get_ad_accounts',
@@ -26,7 +26,13 @@ __all__ = [
     'get_insights',
     'get_login_link',
     'login_cli',
-    'main'
+    'main',
+    'search_interests',
+    'get_interest_suggestions',
+    'validate_interests',
+    'search_behaviors',
+    'search_demographics',
+    'search_geo_locations'
 ]
 
 # Import key functions to make them available at package level
@@ -47,7 +53,13 @@ from .core import (
     get_insights,
     get_login_link,
     login_cli,
-    main
+    main,
+    search_interests,
+    get_interest_suggestions,
+    validate_interests,
+    search_behaviors,
+    search_demographics,
+    search_geo_locations
 )
 
 # Define a main function to be used as a package entry point

{meta_ads_mcp-0.6.0 → meta_ads_mcp-0.7.1}/meta_ads_mcp/core/__init__.py

@@ -11,6 +11,7 @@ from .server import login_cli, main
 from .auth import login
 from .ads_library import search_ads_archive
 from .budget_schedules import create_budget_schedule
+from .targeting import search_interests, get_interest_suggestions, validate_interests, search_behaviors, search_demographics, search_geo_locations
 from . import reports  # Import module to register conditional tools
 from . import duplication  # Import module to register conditional duplication tools
 from .openai_deep_research import search, fetch  # OpenAI MCP Deep Research tools
@@ -37,6 +38,12 @@ __all__ = [
     'main',
     'search_ads_archive',
     'create_budget_schedule',
+    'search_interests',
+    'get_interest_suggestions',
+    'validate_interests',
+    'search_behaviors',
+    'search_demographics',
+    'search_geo_locations',
     'search',  # OpenAI MCP Deep Research search tool
     'fetch',   # OpenAI MCP Deep Research fetch tool
 ] 

{meta_ads_mcp-0.6.0 → meta_ads_mcp-0.7.1}/meta_ads_mcp/core/authentication.py

@@ -1,4 +1,27 @@
-"""Authentication-specific functionality for Meta Ads API."""
+"""Authentication-specific functionality for Meta Ads API.
+
+The Meta Ads MCP server supports three authentication modes:
+
+1. **Development/Local Mode** (default)
+   - Uses local callback server on localhost:8080+ for OAuth redirect
+   - Requires META_ADS_DISABLE_CALLBACK_SERVER to NOT be set
+   - Best for local development and testing
+
+2. **Production with API Token** 
+   - Uses PIPEBOARD_API_TOKEN for server-to-server authentication
+   - Bypasses OAuth flow entirely
+   - Best for server deployments with pre-configured tokens
+
+3. **Production OAuth Flow** (NEW)
+   - Uses Pipeboard OAuth endpoints for dynamic client registration
+   - Triggered when META_ADS_DISABLE_CALLBACK_SERVER is set but no PIPEBOARD_API_TOKEN
+   - Supports MCP clients that implement OAuth 2.0 discovery
+
+Environment Variables:
+- PIPEBOARD_API_TOKEN: Enables mode 2 (token-based auth)  
+- META_ADS_DISABLE_CALLBACK_SERVER: Disables local server, enables mode 3
+- META_ACCESS_TOKEN: Direct Meta token (fallback)
+"""
 
 import json
 import asyncio
@@ -27,41 +50,49 @@ async def get_login_link(access_token: str = None) -> str:
     """
     # Check if we're using pipeboard authentication
     using_pipeboard = bool(os.environ.get("PIPEBOARD_API_TOKEN", ""))
+    callback_server_disabled = bool(os.environ.get("META_ADS_DISABLE_CALLBACK_SERVER", ""))
     
     if using_pipeboard:
-        # Handle Pipeboard authentication
-        # Check if we have a cached token
-        cached_token = pipeboard_auth_manager.get_access_token()
-        token_status = "No token" if not cached_token else "Valid token"
-        
-        # If we already have a valid token and none was provided, just return success
-        if cached_token and not access_token:
-            logger.info("get_login_link called with existing valid Pipeboard token")
-            return json.dumps({
-                "message": "Already authenticated with Pipeboard",
-                "token_status": token_status,
-                "token_preview": cached_token[:10] + "..." if cached_token else None,
-                "authentication_method": "pipeboard"
-            }, indent=2)
-        
-        # Initiate the auth flow via Pipeboard
+        # Pipeboard token-based authentication
         try:
-            auth_data = pipeboard_auth_manager.initiate_auth_flow()
-            login_url = auth_data.get("loginUrl")
+            logger.info("Using Pipeboard token-based authentication")
             
-            # Return a special format that helps the LLM format the response properly
-            response = {
-                "login_url": login_url,
-                "token_status": token_status,
-                "markdown_link": f"[Click here to authenticate with Meta Ads via Pipeboard]({login_url})",
-                "message": "IMPORTANT: Please use the Markdown link format in your response to allow the user to click it.",
-                "instructions_for_llm": "You must present this link as clickable Markdown to the user using the markdown_link format provided.",
-                "authentication_method": "pipeboard",
-                "token_duration": "Approximately 60 days",
-                "note": "After authenticating, the token will be automatically saved."
-            }
+            # If an access token was provided, this is likely a test - return success
+            if access_token:
+                return json.dumps({
+                    "message": "Manual token provided",
+                    "token_status": "Provided token",
+                    "authentication_method": "manual_token"
+                }, indent=2)
+            
+            # Check if Pipeboard token is working
+            token = pipeboard_auth_manager.get_access_token()
+            if token:
+                return json.dumps({
+                    "message": "Already authenticated via Pipeboard",
+                    "token_status": "Valid Pipeboard token",
+                    "authentication_method": "pipeboard_token"
+                }, indent=2)
             
-            return json.dumps(response, indent=2)
+            # Start Pipeboard auth flow
+            auth_data = pipeboard_auth_manager.initiate_auth_flow()
+            login_url = auth_data.get('loginUrl')
+            
+            if login_url:
+                return json.dumps({
+                    "login_url": login_url,
+                    "markdown_link": f"[Click here to authenticate with Meta Ads via Pipeboard]({login_url})",
+                    "message": "IMPORTANT: Please use the Markdown link format in your response to allow the user to click it.",
+                    "instructions_for_llm": "You must present this link as clickable Markdown to the user using the markdown_link format provided.",
+                    "authentication_method": "pipeboard_oauth",
+                    "note": "After authenticating, the token will be automatically retrieved from Pipeboard."
+                }, indent=2)
+            else:
+                return json.dumps({
+                    "error": "No login URL received from Pipeboard",
+                    "authentication_method": "pipeboard_oauth_failed"
+                }, indent=2)
+                
         except Exception as e:
             logger.error(f"Error initiating Pipeboard auth flow: {e}")
             return json.dumps({
@@ -69,8 +100,22 @@ async def get_login_link(access_token: str = None) -> str:
                 "message": "Please check your PIPEBOARD_API_TOKEN environment variable.",
                 "authentication_method": "pipeboard"
             }, indent=2)
+    elif callback_server_disabled:
+        # Production OAuth flow - use Pipeboard OAuth endpoints directly
+        logger.info("Production OAuth flow - using Pipeboard OAuth endpoints")
+        
+        return json.dumps({
+            "authorization_endpoint": "https://pipeboard.co/oauth/authorize", 
+            "token_endpoint": "https://pipeboard.co/oauth/token",
+            "registration_endpoint": "https://pipeboard.co/oauth/register",
+            "discovery_endpoint": "/.well-known/oauth-authorization-server",
+            "message": "Production OAuth flow - use dynamic client registration",
+            "instructions": "MCP clients should use the OAuth discovery endpoint to get authorization URLs",
+            "authentication_method": "production_oauth",
+            "note": "For manual authentication, clients need to register with Pipeboard OAuth service first"
+        }, indent=2)
     else:
-        # Original Meta authentication flow
+        # Original Meta authentication flow (development/local)
         # Check if we have a cached token
         cached_token = auth_manager.get_access_token()
         token_status = "No token" if not cached_token else "Valid token"

meta_ads_mcp-0.7.1/meta_ads_mcp/core/targeting.py

@@ -0,0 +1,185 @@
+"""Targeting search functionality for Meta Ads API."""
+
+import json
+from typing import Optional, List, Dict, Any
+from .api import meta_api_tool, make_api_request
+from .server import mcp_server
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def search_interests(access_token: str = None, query: str = None, limit: int = 25) -> str:
+    """
+    Search for interest targeting options by keyword.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        query: Search term for interests (e.g., "baseball", "cooking", "travel")
+        limit: Maximum number of results to return (default: 25)
+    
+    Returns:
+        JSON string containing interest data with id, name, audience_size, and path fields
+    """
+    if not query:
+        return json.dumps({"error": "No search query provided"}, indent=2)
+    
+    endpoint = "search"
+    params = {
+        "type": "adinterest",
+        "q": query,
+        "limit": limit
+    }
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2)
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def get_interest_suggestions(access_token: str = None, interest_list: List[str] = None, limit: int = 25) -> str:
+    """
+    Get interest suggestions based on existing interests.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)  
+        interest_list: List of interest names to get suggestions for (e.g., ["Basketball", "Soccer"])
+        limit: Maximum number of suggestions to return (default: 25)
+    
+    Returns:
+        JSON string containing suggested interests with id, name, audience_size, and description fields
+    """
+    if not interest_list:
+        return json.dumps({"error": "No interest list provided"}, indent=2)
+    
+    endpoint = "search"
+    params = {
+        "type": "adinterestsuggestion", 
+        "interest_list": json.dumps(interest_list),
+        "limit": limit
+    }
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2)
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def validate_interests(access_token: str = None, interest_list: List[str] = None, 
+                           interest_fbid_list: List[str] = None) -> str:
+    """
+    Validate interest names or IDs for targeting.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        interest_list: List of interest names to validate (e.g., ["Japan", "Basketball"])
+        interest_fbid_list: List of interest IDs to validate (e.g., ["6003700426513"])
+    
+    Returns:
+        JSON string with validation results showing valid status and audience_size for each interest
+    """
+    if not interest_list and not interest_fbid_list:
+        return json.dumps({"error": "No interest list or FBID list provided"}, indent=2)
+    
+    endpoint = "search"
+    params = {
+        "type": "adinterestvalid"
+    }
+    
+    if interest_list:
+        params["interest_list"] = json.dumps(interest_list)
+    
+    if interest_fbid_list:
+        params["interest_fbid_list"] = json.dumps(interest_fbid_list)
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2)
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def search_behaviors(access_token: str = None, limit: int = 50) -> str:
+    """
+    Get all available behavior targeting options.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        limit: Maximum number of results to return (default: 50)
+    
+    Returns:
+        JSON string containing behavior targeting options with id, name, audience_size bounds, path, and description
+    """
+    endpoint = "search"
+    params = {
+        "type": "adTargetingCategory",
+        "class": "behaviors",
+        "limit": limit
+    }
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2)
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def search_demographics(access_token: str = None, demographic_class: str = "demographics", limit: int = 50) -> str:
+    """
+    Get demographic targeting options.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        demographic_class: Type of demographics to retrieve. Options: 'demographics', 'life_events', 
+                          'industries', 'income', 'family_statuses', 'user_device', 'user_os' (default: 'demographics')
+        limit: Maximum number of results to return (default: 50)
+    
+    Returns:
+        JSON string containing demographic targeting options with id, name, audience_size bounds, path, and description
+    """
+    endpoint = "search"
+    params = {
+        "type": "adTargetingCategory",
+        "class": demographic_class,
+        "limit": limit
+    }
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2)
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def search_geo_locations(access_token: str = None, query: str = None, 
+                             location_types: List[str] = None, limit: int = 25) -> str:
+    """
+    Search for geographic targeting locations.
+    
+    Args:
+        access_token: Meta API access token (optional - will use cached token if not provided)
+        query: Search term for locations (e.g., "New York", "California", "Japan")
+        location_types: Types of locations to search. Options: ['country', 'region', 'city', 'zip', 
+                       'geo_market', 'electoral_district']. If not specified, searches all types.
+        limit: Maximum number of results to return (default: 25)
+    
+    Returns:
+        JSON string containing location data with key, name, type, and geographic hierarchy information
+    """
+    if not query:
+        return json.dumps({"error": "No search query provided"}, indent=2)
+    
+    endpoint = "search"
+    params = {
+        "type": "adgeolocation",
+        "q": query,
+        "limit": limit
+    }
+    
+    if location_types:
+        params["location_types"] = json.dumps(location_types)
+    
+    data = await make_api_request(endpoint, access_token, params)
+    
+    return json.dumps(data, indent=2) 

{meta_ads_mcp-0.6.0 → meta_ads_mcp-0.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meta-ads-mcp"
-version = "0.6.0"
+version = "0.7.1"
 description = "Model Context Protocol (MCP) plugin for interacting with Meta Ads API"
 readme = "README.md"
 requires-python = ">=3.10"