Google Cloud의 Vertex AI Agent Builder로 데모를 프로덕션으로 전환하기

const https = require('https');

const API_KEY = "YOUR_SERPAPI_KEY";

exports.foodSearch = (req, res) => {
  console.log("🔵 Function triggered");

  try {
    const { location, latitude, longitude, query, cuisine } = req.body;

    if (!query) {
      console.error("❌ Missing 'query' parameter:", req.body);
      return res.status(400).json({ error: "Missing required parameter 'query'" });
    }

    // Construct search query
    let searchQuery = query;
    if (cuisine) {
      searchQuery += ` ${cuisine}`;
    }

    let searchParams;
    if (latitude && longitude) {
      console.log(`🌍 Using latitude/longitude: ${latitude}, ${longitude}`);
      searchParams = `ll=@${latitude},${longitude},14z`;
    } else if (location) {
      console.log(`📍 Using location string: ${location}`);
      searchParams = `location=${encodeURIComponent(location)}`;
    } else {
      console.error("❌ Missing location parameters (either 'location' or 'latitude/longitude' required)");
      return res.status(400).json({ error: "Missing location parameters. Provide 'location' or 'latitude/longitude'." });
    }

    const url = `https://serpapi.com/search?engine=google_local&q=${encodeURIComponent(searchQuery)}&${searchParams}&api_key=${API_KEY}`;

    console.log("🟠 Requesting:", url);

    https.get(url, (apiRes) => {
      let data = '';

      apiRes.on('data', (chunk) => {
        data += chunk;
      });

      apiRes.on('end', () => {
        console.log("🟢 API Response received");

        try {
          const jsonResponse = JSON.parse(data);

          if (!jsonResponse.local_results || jsonResponse.local_results.length === 0) {
            console.warn("⚠️ No food places found in API response.");
            return res.status(404).json({ error: "No food places found" });
          }

          const foodPlaces = jsonResponse.local_results.map(place => ({
            name: place.title || "Unknown",
            rating: place.rating || "N/A",
            reviews: place.reviews || 0
          }));

          console.log("✅ Sending response:", foodPlaces);
          res.setHeader('Content-Type', 'application/json');
          res.status(200).json({ food_places: foodPlaces });

        } catch (err) {
          console.error("🔴 JSON Parse Error:", err.message);
          res.status(500).json({ error: "Failed to parse API response", details: data });
        }
      });

    }).on('error', (err) => {
      console.error("❌ API Request Error:", err.message);
      res.status(500).json({ error: "Failed to fetch data from API", details: err.message });
    });

  } catch (error) {
    console.error("❌ Function Error:", error.message);
    res.status(500).json({ error: "Server error", details: error.message });
  }
};





const https = require('https');

const API_KEY = "YOUR_SERPAPI_KEY";

exports.hotelSearch = (req, res) => {
  console.log("🔵 Function triggered");

  try {
    const { location, check_in_date, check_out_date, adults } = req.body;
    let { currency } = req.body;

    if (!location || !check_in_date || !check_out_date || !adults) {
      console.error("❌ Missing parameters:", req.body);
      return res.status(400).json({ error: "Missing required parameters", received: req.body });
    }

    // Default currency to USD if not provided
    currency = currency || "USD";

    const url = `https://serpapi.com/search?engine=google_hotels&q=${encodeURIComponent(location)}&check_in_date=${encodeURIComponent(check_in_date)}&check_out_date=${encodeURIComponent(check_out_date)}&adults=${encodeURIComponent(adults)}&currency=${encodeURIComponent(currency)}&api_key=${API_KEY}`;

    console.log("🟠 Requesting:", url);

    https.get(url, (apiRes) => {
      let data = '';

      apiRes.on('data', (chunk) => {
        data += chunk;
      });

      apiRes.on('end', () => {
        console.log("🟢 API Response received");

        try {
          const jsonResponse = JSON.parse(data);

          if (!jsonResponse.properties || jsonResponse.properties.length === 0) {
            console.warn("⚠️ No hotels found in API response.");
            return res.status(404).json({ error: "No hotels found" });
          }

          const hotels = jsonResponse.properties.map(hotel => ({
            name: hotel.name || "No Name",
            price: hotel.rate_per_night?.lowest || "N/A",
            currency: currency, // Include currency for clarity
            lat: hotel.gps_coordinates?.latitude || null,
            lon: hotel.gps_coordinates?.longitude || null,
            link: hotel.link || "N/A"
          }));

          console.log("✅ Sending response:", hotels);
          res.setHeader('Content-Type', 'application/json');
          res.status(200).json({ hotels });

        } catch (err) {
          console.error("🔴 JSON Parse Error:", err.message);
          res.status(500).json({ error: "Failed to parse API response", details: data });
        }
      });

    }).on('error', (err) => {
      console.error("❌ API Request Error:", err.message);
      res.status(500).json({ error: "Failed to fetch data from API", details: err.message });
    });

  } catch (error) {
    console.error("❌ Function Error:", error.message);
    res.status(500).json({ error: "Server error", details: error.message });
  }
};


import uuid
import json
import weave
from google.cloud import dialogflowcx_v3beta1 as dialogflow

weave_client = weave.init("vertex-agent")

# Add token cost configuration
weave_client.add_cost(
    llm_id="gemini_flash_002", 
    prompt_token_cost=0.00001875,  # Cost per 1,000 characters when <= 128k input tokens 
    completion_token_cost=0.000075  # Cost per 1,000 characters
)


# Dialogflow CX configuration
PROJECT_ID = "your gcloud project"
LOCATION_ID = "us-central1"
AGENT_ID = "your agent ID"
LANGUAGE_CODE = "en"

SESSION_ID = str(uuid.uuid4())  # Generate a persistent session ID

def simple_token_count(text: str) -> int:
    """Simple token count excluding whitespaces."""
    return len(text.replace(" ", ""))

@weave.op
def run_dialogflow_inference(text, session_id=SESSION_ID):
    """Sends a text query to Dialogflow CX and returns bot reply, tool input params, and tool output."""
    api_endpoint = f"{LOCATION_ID}-dialogflow.googleapis.com"
    client_options = {"api_endpoint": api_endpoint}
    session_client = dialogflow.SessionsClient(client_options=client_options)

    session_path = f"projects/{PROJECT_ID}/locations/{LOCATION_ID}/agents/{AGENT_ID}/sessions/{session_id}"

    text_input = dialogflow.TextInput(text=text)
    query_input = dialogflow.QueryInput(text=text_input, language_code=LANGUAGE_CODE)
    request = dialogflow.DetectIntentRequest(session=session_path, query_input=query_input)

    # Count input tokens before making the request
    input_tokens = simple_token_count(text)

    response = session_client.detect_intent(request=request)

    # Convert response to JSON for inspection
    response_dict = json.loads(response.__class__.to_json(response))
    print(json.dumps(response_dict, indent=2))  # Print full response for debugging

    # Extract bot reply safely
    bot_reply = "No response from agent."
    qr = response_dict.get("queryResult", {})
    rm = qr.get("responseMessages", [])
    if rm and rm[0].get("text", {}).get("text"):
        bot_reply = rm[0]["text"]["text"][0]

    # Count output tokens
    output_tokens = simple_token_count(bot_reply)

    # Extract toolCall data from actionTracingInfo
    tool_input_params = None
    tool_output = None

    action_tracing_info = qr.get("generativeInfo", {}).get("actionTracingInfo", {})
    if "actions" in action_tracing_info:
        for action in action_tracing_info["actions"]:
            if "toolUse" in action:
                tool_call_data = action["toolUse"]
                tool_input_params = tool_call_data.get("inputActionParameters", {}).get("requestBody", {})
                tool_output = tool_call_data.get("outputActionParameters", {}).get("200", {})

                print("TOOL INPUT PARAMS:", json.dumps(tool_input_params, indent=2))
                print("TOOL OUTPUT:", json.dumps(tool_output, indent=2))

                # Adjust token counts for tool input/output
                output_tokens += simple_token_count(str(tool_input_params))
                input_tokens += simple_token_count(str(tool_output))

    # Return response with token usage information
    return {
        "bot_reply": bot_reply,
        "tool_input_params": tool_input_params,
        "tool_output": tool_output,
        "model": "gemini_flash_002",
        "usage": {
            "input_tokens": input_tokens,
            "output_tokens": output_tokens,
            "total_tokens": input_tokens + output_tokens
        }
    }

# Example chat loop
if __name__ == "__main__":
    print("Start chatting with the agent (type 'exit' to stop):")

    while True:
        user_text = input("You: ")
        if user_text.lower() in ["exit", "quit"]:
            break

        # Set AGENT_ID and SESSION_ID for each call inside main
        with weave.attributes({"AGENT_ID": AGENT_ID, "SESSION_ID": SESSION_ID}):
            response = run_dialogflow_inference(user_text, SESSION_ID)

        print(f"Bot: {response['bot_reply']}")
        if response["tool_input_params"]:
            print(f"Function Input Params: {response['tool_input_params']}")
        if response["tool_output"]:
            print(f"Function Output: {response['tool_output']}")
        print(f"Token Usage: {response['usage']}")


"model": "gemini_flash_002",
"usage": {
    "input_tokens": input_tokens,
    "output_tokens": output_tokens,
    "total_tokens": input_tokens + output_tokens
}

weave_client = weave.init("vertex-agent")
weave_client.add_cost(
    llm_id="gemini_flash_002", 
    prompt_token_cost=0.00001875,  # Cost per 1,000 characters when <= 128k input tokens 
    completion_token_cost=0.000075  # Cost per 1,000 characters when <= 128k input tokens 
)