# Create Google Cloud project
gcloud projects create my-agent-project
gcloud config set project my-agent-project
 
# Enable required APIs
gcloud services enable \
  aiplatform.googleapis.com \
  cloudfunctions.googleapis.com \
  run.googleapis.com \
  storage-api.googleapis.com \
  bigquery.googleapis.com

from google.cloud import aiplatform
 
def create_agent_with_custom_prompt(project_id, region, agent_name, prompt_text):
    """Create agent with custom system prompt"""
 
    client = aiplatform.gapic.v1.AgentsClient(
        client_options={"api_endpoint": f"{region}-aiplatform.googleapis.com"}
    )
 
    location = client.common_location_path(project_id, region)
 
    # Agent configuration
    agent = {
        "display_name": agent_name,
        "description": "Custom Gemini Agent",
        "system_instruction": {
            "parts": [{"text": prompt_text}]
        },
        "model": "gemini-2.5-pro"
    }
 
    request = {
        "parent": location,
        "agent": agent
    }
 
    response = client.create_agent(request)
    return response
 
# Usage example
prompt = """You are a technical support agent.
Diagnose user technical issues and provide step-by-step solutions."""
 
agent = create_agent_with_custom_prompt(
    project_id="my-project",
    region="us-central1",
    agent_name="technical-support",
    prompt_text=prompt
)

# Upload documents
gsutil cp -r ./documents/* gs://my-knowledge-base/docs/

-- Example BigQuery table
CREATE TABLE `my-project.agent_data.products` (
  product_id STRING,
  product_name STRING,
  description STRING,
  price FLOAT64,
  stock_quantity INT64,
  created_at TIMESTAMP
);
 
-- Insert sample data
INSERT INTO `my-project.agent_data.products` VALUES
  ('PROD001', 'Python Basics Book', 'Python beginner guide', 28.00, 150, CURRENT_TIMESTAMP()),
  ('PROD002', 'API Design Guide', 'REST API best practices', 35.00, 80, CURRENT_TIMESTAMP());

# Cloud Functions: product_lookup.py
import functions_framework
import json
from google.cloud import bigquery
 
client = bigquery.Client()
 
@functions_framework.http
def lookup_product(request):
    """Look up product information"""
 
    request_json = request.get_json()
    product_id = request_json.get('product_id')
 
    if not product_id:
        return json.dumps({
            "status": "error",
            "message": "product_id is required"
        }), 400
 
    # BigQuery query
    query = f"""
    SELECT
      product_id,
      product_name,
      description,
      price,
      stock_quantity
    FROM `my-project.agent_data.products`
    WHERE product_id = '{product_id}'
    LIMIT 1
    """
 
    results = list(client.query(query).result())
 
    if results:
        product = results[0]
        return json.dumps({
            "status": "success",
            "product": {
                "id": product['product_id'],
                "name": product['product_name'],
                "description": product['description'],
                "price": float(product['price']),
                "stock": int(product['stock_quantity'])
            }
        }), 200
    else:
        return json.dumps({
            "status": "not_found",
            "message": f"Product {product_id} not found"
        }), 404
 
# Deploy
# gcloud functions deploy lookup_product \
#   --runtime python311 \
#   --trigger-http \
#   --allow-unauthenticated

{
  "name": "product_lookup",
  "description": "Get product information by product ID",
  "endpoint": "https://REGION-my-project.cloudfunctions.net/lookup_product",
  "method": "POST",
  "parameters": [
    {
      "name": "product_id",
      "type": "string",
      "description": "Product ID (e.g., PROD001)",
      "required": true
    }
  ],
  "response_schema": {
    "type": "object",
    "properties": {
      "status": {"type": "string"},
      "product": {
        "type": "object",
        "properties": {
          "id": {"type": "string"},
          "name": {"type": "string"},
          "price": {"type": "number"},
          "stock": {"type": "integer"}
        }
      }
    }
  }
}

# Get agent ID
AGENT_ID="projects/my-project/locations/us-central1/agents/abc123"
 
# Deploy to Cloud Run
gcloud run deploy my-agent \
  --image gcr.io/cloud-ai-solutions/agent-runtime:latest \
  --environment-variables AGENT_ID=$AGENT_ID \
  --region us-central1 \
  --allow-unauthenticated

import requests
 
class AgentAPIClient:
    """Vertex AI Agent API client"""
 
    def __init__(self, endpoint_url, api_key):
        self.endpoint = endpoint_url
        self.api_key = api_key
 
    def send_message(self, user_message, session_id=None):
        """Send message to agent"""
 
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
 
        payload = {
            "user_input": user_message,
            "session_id": session_id or "default-session"
        }
 
        response = requests.post(
            f"{self.endpoint}/chat",
            headers=headers,
            json=payload
        )
 
        if response.status_code == 200:
            return response.json()
        else:
            raise Exception(f"API Error: {response.status_code}")
 
    def get_session_history(self, session_id):
        """Get session conversation history"""
 
        headers = {
            "Authorization": f"Bearer {self.api_key}"
        }
 
        response = requests.get(
            f"{self.endpoint}/sessions/{session_id}/history",
            headers=headers
        )
 
        return response.json() if response.status_code == 200 else []
 
# Usage example
client = AgentAPIClient(
    endpoint_url="https://REGION-my-project.run.app",
    api_key="your-api-key"
)
 
# Send message
response = client.send_message(
    user_message="Compare prices of PROD001 and PROD002",
    session_id="user-123"
)
 
print("Agent response:", response.get("response"))
print("Tools used:", response.get("tools_used", []))
 
# Check session history
history = client.get_session_history("user-123")
for msg in history:
    print(f"{msg['role']}: {msg['content']}")

# View logs
gcloud logging read \
  "resource.type=cloud_run_revision AND \
   resource.labels.service_name=my-agent" \
  --limit 50
 
# Filter for errors only
gcloud logging read \
  "severity=ERROR AND resource.type=cloud_run_revision" \
  --limit 20

from google.cloud import logging as cloud_logging
from datetime import datetime, timedelta
 
def analyze_agent_usage(project_id, hours=24):
    """Analyze agent usage statistics"""
 
    logging_client = cloud_logging.Client(project=project_id)
 
    # Get logs from last 24 hours
    start_time = datetime.utcnow() - timedelta(hours=hours)
 
    filter_str = f"""
    timestamp >= "{start_time.isoformat()}Z" AND
    resource.type="cloud_run_revision" AND
    jsonPayload.agent_id="{project_id}"
    """
 
    entries = logging_client.list_entries(filter_=filter_str)
 
    stats = {
        "total_messages": 0,
        "successful_queries": 0,
        "failed_queries": 0,
        "average_response_time": 0,
        "tools_used": {}
    }
 
    response_times = []
 
    for entry in entries:
        payload = entry.payload
        stats["total_messages"] += 1
 
        if payload.get("status") == "success":
            stats["successful_queries"] += 1
        else:
            stats["failed_queries"] += 1
 
        if "response_time_ms" in payload:
            response_times.append(payload["response_time_ms"])
 
        for tool in payload.get("tools_used", []):
            stats["tools_used"][tool] = stats["tools_used"].get(tool, 0) + 1
 
    if response_times:
        stats["average_response_time"] = sum(response_times) / len(response_times)
 
    return stats
 
# Usage example
usage = analyze_agent_usage("my-project")
print(f"Total messages: {usage['total_messages']}")
print(f"Success: {usage['successful_queries']}, Failed: {usage['failed_queries']}")
print(f"Avg response time: {usage['average_response_time']:.2f}ms")
print(f"Tools used: {usage['tools_used']}")

# Minimize service account permissions
gcloud iam roles create agent-runtime-role \
  --permissions=bigquery.dataEditor,storage.objectViewer,run.invoker
 
# Encrypt conversation history with CMEK
gcloud firestore databases create \
  --database-type=firestore-native \
  --cmek-config=projects/my-project/locations/global/keyRings/my-keyring/cryptoKeys/my-key