10_2_2_Tool_Use_for_Structured_Outputs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Appendix 10.2.2: Forcing JSON with tool use\n",
    "\n",
    "## Learning goals\n",
    "\n",
    "* Understand using tools to force a structured response\n",
    "* Utilize this \"trick\" to generate structured JSON\n",
    "\n",
    "One of the more interesting ways of utilizing tool use is in forcing Claude to respond with structured content like JSON.  There are many situations in which we may want to get a standardized JSON response from Claude: extracting entities, summarizing data, analyzing sentiment, etc. \n",
    "\n",
    "One way of doing this is simply asking Claude to respond with JSON, but this can require additional work to actually extract the JSON from the big string we get back from Claude or to make sure the JSON follows the exact format we want.\n",
    "\n",
    "The good news is that **whenever Claude wants to use a tool, it already responds using the perfectly structured format we told it to use when we defined the tool.**\n",
    "\n",
    "In the previous lesson, we gave Claude a calculator tool.  When it wanted to use the tool, it responded with content like this: \n",
    "\n",
    "```\n",
    "{\n",
    "    'operand1': 1984135, \n",
    "    'operand2': 9343116, \n",
    "    'operation': 'multiply'\n",
    "}\n",
    "```\n",
    "\n",
    "That looks suspiciously similar to JSON! \n",
    "\n",
    "If we want Claude to generate structured JSON, we can use this to our advantage.  All we have to do is define a tool that describes a particular JSON structure and then tell Claude about it.  That's it.  Claude will respond back, thinking it's \"calling a tool\" but really all we care about is the structured response it gives us."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conceptual overview\n",
    "\n",
    "How is this different than what we did in the previous lesson?  Here's a diagram of the workflow from the last lesson: \n",
    "\n",
    "![chickens_calculator.png](./images/chickens_calculator.png)\n",
    "\n",
    "In the last lesson, we gave Claude access to a tool, Claude wanted to call it, and then we actually called the underlying tool function.\n",
    "\n",
    "In this lesson, we're going to \"trick\" Claude by telling it about a particular tool, but we won't need to actually call the underlying tool function.  We're using the tool as a way of forcing a particular structure of response, as seen in this diagram:\n",
    "\n",
    "![structured_response.png](./images/structured_response.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sentiment analysis\n",
    "Let's start with a simple example.  Suppose we want Claude to analyze the sentiment in some text and respond with a JSON object that follows this shape: \n",
    "\n",
    "```\n",
    "{\n",
    "  \"negative_score\": 0.6,\n",
    "  \"neutral_score\": 0.3,\n",
    "  \"positive_score\": 0.1\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All we have to do is define a tool that captures this shape using JSON Schema.  Here's a potential implementation: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%pip install -qU pip\n",
    "%pip install -qUr requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import boto3\n",
    "import json\n",
    "from datetime import datetime\n",
    "from botocore.exceptions import ClientError\n",
    "\n",
    "# Import the hints module from the utils package\n",
    "from utils import hints\n",
    "\n",
    "session = boto3.Session()\n",
    "region = session.region_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "modelId = 'anthropic.claude-3-sonnet-20240229-v1:0'\n",
    "#modelId = 'anthropic.claude-3-haiku-20240307-v1:0'\n",
    "\n",
    "bedrock_client = boto3.client(service_name = 'bedrock-runtime', region_name = region,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tools = {\n",
    "  \"tools\": [\n",
    "    {\n",
    "      \"toolSpec\": {\n",
    "        \"name\": \"print_sentiment_scores\",\n",
    "        \"description\": \"Prints the sentiment scores of a given text.\",\n",
    "        \"inputSchema\": {\n",
    "          \"json\": {\n",
    "            \"type\": \"object\",\n",
    "            \"properties\": {\n",
    "              \"positive_score\": {\n",
    "                \"type\": \"number\",\n",
    "                \"description\": \"The positive sentiment score, ranging from 0.0 to 1.0.\"},\n",
    "              \"negative_score\": {\n",
    "                \"type\": \"number\",\n",
    "                \"description\": \"The negative sentiment score, ranging from 0.0 to 1.0.\"},\n",
    "              \"neutral_score\": {\n",
    "                \"type\": \"number\",\n",
    "                \"description\": \"The neutral sentiment score, ranging from 0.0 to 1.0.\"}\n",
    "            },\n",
    "            \"required\": [\"positive_score\", \"negative_score\", \"neutral_score\"\n",
    "            ]\n",
    "          }\n",
    "        }\n",
    "      }\n",
    "    }\n",
    "  ]\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can tell Claude about this tool and explicitly tell Claude to use it, to ensure that it actually does use it.  We should get a response telling us that Claude wants to use a tool.  The tool use response should contain all the data in the exact format we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tweet = \"I'm a HUGE hater of pickles.  I actually despise pickles.  They are garbage.\"\n",
    "\n",
    "query = f\"\"\"\n",
    "<text>\n",
    "{tweet}\n",
    "</text>\n",
    "\n",
    "Only use the print_sentiment_scores tool.\n",
    "\"\"\"\n",
    "\n",
    "converse_api_params = {\n",
    "    \"modelId\": \"anthropic.claude-3-haiku-20240307-v1:0\",\n",
    "    \"messages\": [{\"role\": \"user\", \"content\": [{\"text\": query}]}],\n",
    "    \"inferenceConfig\": {\"temperature\": 0.0, \"maxTokens\": 400},\n",
    "    \"toolConfig\": tools,\n",
    "}\n",
    "\n",
    "response = bedrock_client.converse(**converse_api_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "response['output']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the response we get back from Claude.  We've bolded the important part:\n",
    "\n",
    ">{'message': {'role': 'assistant',\n",
    "  'content': [{'text': 'Here is the sentiment analysis for the given text:'},\n",
    "   {'toolUse': {'toolUseId': 'tooluse_d2ReNcjDQvKjLLet4u9EOA',\n",
    "     'name': 'print_sentiment_scores',\n",
    "     **'input': {'positive_score': 0.0,\n",
    "      'negative_score': 0.7,\n",
    "      'neutral_score': 0.3}**}}]}}\n",
    "\n",
    "Claude \"thinks\" it's calling a tool that will use this sentiment analysis data, but really we're just going to extract the data and turn it into JSON:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import json\n",
    "json_sentiment = None\n",
    "for content in response['output']['message']['content']:\n",
    "    if isinstance(content, dict) and 'toolUse' in content:\n",
    "        tool_use = content['toolUse']\n",
    "        if tool_use['name'] == \"print_sentiment_scores\":\n",
    "            json_sentiment = tool_use['input']\n",
    "            break\n",
    "\n",
    "if json_sentiment:\n",
    "    print(\"Sentiment Analysis (JSON):\")\n",
    "    print(json.dumps(json_sentiment, indent=2))\n",
    "else:\n",
    "    print(\"No sentiment analysis found in the response.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It works! Now let's turn that into a reusable function that takes a tweet or article and then prints or returns the sentiment analysis as JSON."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def analyze_sentiment(content):\n",
    "\n",
    "    query = f\"\"\"\n",
    "    <text>\n",
    "    {content}\n",
    "    </text>\n",
    "\n",
    "    Only use the print_sentiment_scores tool.\n",
    "    \"\"\"\n",
    "\n",
    "    converse_api_params = {\n",
    "        \"modelId\": \"anthropic.claude-3-haiku-20240307-v1:0\",\n",
    "        \"messages\": [{\"role\": \"user\", \"content\": [{\"text\": query}]}],\n",
    "        \"inferenceConfig\": {\"temperature\": 0.0, \"maxTokens\": 4096},\n",
    "        \"toolConfig\": tools,\n",
    "    }\n",
    "\n",
    "    response = bedrock_client.converse(**converse_api_params)\n",
    "\n",
    "    json_sentiment = None\n",
    "    for content in response['output']['message']['content']:\n",
    "        if isinstance(content, dict) and 'toolUse' in content:\n",
    "            tool_use = content['toolUse']\n",
    "            if tool_use['name'] == \"print_sentiment_scores\":\n",
    "                json_sentiment = tool_use['input']\n",
    "                break\n",
    "\n",
    "    if json_sentiment:\n",
    "        print(\"Sentiment Analysis (JSON):\")\n",
    "        print(json.dumps(json_sentiment, indent=2))\n",
    "    else:\n",
    "        print(\"No sentiment analysis found in the response.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "analyze_sentiment(\"OMG I absolutely love taking bubble baths soooo much!!!!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "analyze_sentiment(\"Honestly I have no opinion on taking baths\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Forcing tool use with `toolChoice` \n",
    "\n",
    "Currently we're \"forcing\" Claude to use our `print_sentiment_scores` tool through prompting.  In our prompt, we write `Only use the print_sentiment_scores tool.` which usually works, but there's a better way! We can actually force Claude to use a specific tool using the `tool_choice` parameter:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "```json\n",
    "tool_choice = {\n",
    "    \"tool\": {\n",
    "        \"name\": \"print_sentiment_scores\"}\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code tells Claude that it must respond by calling the `print_sentiment_scores` tool.  Let's update our tools and function to use it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create out toolConfig var and force the toolChoice to be print_sentiment_scores by name\n",
    "toolConfig = {'tools': [],\n",
    "        \"toolChoice\": {\n",
    "        \"tool\": {\"name\":\"print_sentiment_scores\"},\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# append our tool specification to our toolConfig\n",
    "toolConfig['tools'].append({\n",
    "      \"toolSpec\": {\n",
    "        \"name\": \"print_sentiment_scores\",\n",
    "        \"description\": \"Prints the sentiment scores of a given text.\",\n",
    "        \"inputSchema\": {\n",
    "          \"json\": {\n",
    "            \"type\": \"object\",\n",
    "            \"properties\": {\n",
    "              \"positive_score\": {\n",
    "                \"type\": \"number\",\n",
    "                \"description\": \"The positive sentiment score, ranging from 0.0 to 1.0.\"},\n",
    "              \"negative_score\": {\n",
    "                \"type\": \"number\",\n",
    "                \"description\": \"The negative sentiment score, ranging from 0.0 to 1.0.\"},\n",
    "              \"neutral_score\": {\n",
    "                \"type\": \"number\",\n",
    "                \"description\": \"The neutral sentiment score, ranging from 0.0 to 1.0.\"}\n",
    "            },\n",
    "            \"required\": [\"positive_score\", \"negative_score\", \"neutral_score\"]\n",
    "          }\n",
    "        }\n",
    "      }\n",
    "    })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# optional uncomment if you want to see the complete toolConfig\n",
    "toolConfig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def analyze_sentiment(content):\n",
    "\n",
    "    query = f\"\"\"\n",
    "    <text>\n",
    "    {content}\n",
    "    </text>\n",
    "\n",
    "    Only use the print_sentiment_scores tool.\n",
    "    \"\"\"\n",
    "\n",
    "    converse_api_params = {\n",
    "        \"modelId\": \"anthropic.claude-3-haiku-20240307-v1:0\",\n",
    "        \"messages\": [{\"role\": \"user\", \"content\": [{\"text\": query}]}],\n",
    "        \"inferenceConfig\": {\"temperature\": 0.0, \"maxTokens\": 4096},\n",
    "        \"toolConfig\": toolConfig\n",
    "    }\n",
    "\n",
    "    response = bedrock_client.converse(**converse_api_params)\n",
    "\n",
    "    json_sentiment = None\n",
    "    for content in response['output']['message']['content']:\n",
    "        if isinstance(content, dict) and 'toolUse' in content:\n",
    "            tool_use = content['toolUse']\n",
    "            if tool_use['name'] == \"print_sentiment_scores\":\n",
    "                json_sentiment = tool_use['input']\n",
    "                break\n",
    "\n",
    "    if json_sentiment:\n",
    "        print(\"Sentiment Analysis (JSON):\")\n",
    "        print(json.dumps(json_sentiment, indent=2))\n",
    "    else:\n",
    "        print(\"No sentiment analysis found in the response.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "analyze_sentiment(\"Honestly I have no opinion on taking baths\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll cover `toolChoice` in greater detail in an upcoming lesson."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entity extraction example\n",
    "\n",
    "Let's use this same approach to get Claude to generate nicely formatted JSON that contains entities like people, organizations, and locations extracted from a text sample:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "toolConfig = {\n",
    "  \"tools\": [\n",
    "    {\n",
    "      \"toolSpec\": {\n",
    "        \"name\": \"print_entities\",\n",
    "        \"description\": \"Prints extract named entities.\",\n",
    "        \"inputSchema\": {\n",
    "          \"json\": {\n",
    "            \"type\": \"object\",\n",
    "            \"properties\": {\n",
    "              \"entities\": {\n",
    "                \"type\": \"array\",\n",
    "                \"items\": {\n",
    "                  \"type\": \"object\",\n",
    "                  \"properties\": {\n",
    "                    \"name\": {\"type\": \"string\", \"description\": \"The extracted entity name.\"},\n",
    "                    \"type\": {\"type\": \"string\", \"description\": \"The entity type (e.g., PERSON, ORGANIZATION, LOCATION).\"},\n",
    "                    \"context\": {\"type\": \"string\", \"description\": \"The context in which the entity appears in the text.\"}\n",
    "                  },\n",
    "                  \"required\": [\"name\", \"type\", \"context\"]\n",
    "                }\n",
    "              }\n",
    "            },\n",
    "            \"required\": [\"entities\"]\n",
    "          }\n",
    "        }\n",
    "      }\n",
    "    }\n",
    "  ]\n",
    "}\n",
    "\n",
    "text = \"John works at Google in New York. He met with Sarah, the CEO of Acme Inc., last week in San Francisco.\"\n",
    "\n",
    "query = f\"\"\"\n",
    "<document>\n",
    "{text}\n",
    "</document>\n",
    "\n",
    "Use the print_entities tool.\n",
    "\"\"\"\n",
    "\n",
    "converse_api_params = {\n",
    "    \"modelId\": \"anthropic.claude-3-haiku-20240307-v1:0\",\n",
    "    \"messages\": [{\"role\": \"user\", \"content\": [{\"text\": query}]}],\n",
    "    \"additionalModelRequestFields\": {\"max_tokens\": 4096},\n",
    "    \"toolConfig\": toolConfig\n",
    "}\n",
    "\n",
    "response = bedrock_client.converse(**converse_api_params)\n",
    "\n",
    "\n",
    "json_entities = None\n",
    "for content in response['output']['message']['content']:\n",
    "    if isinstance(content, dict) and 'toolUse' in content:\n",
    "        tool_use = content['toolUse']\n",
    "        if tool_use['name'] == \"print_entities\":\n",
    "            json_entities = tool_use['input']\n",
    "            break\n",
    "\n",
    "if json_entities:\n",
    "    print(\"Extracted Entities (JSON):\")\n",
    "    print(json.dumps(json_entities, indent=2))\n",
    "else:\n",
    "    print(\"No entities found in the response.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're using the same \"trick\" as before.  We tell Claude it has access to a tool as a way of getting Claude to respond with a particular data format.  Then we extract the formatted data Claude responded with, and we're good to go. \n",
    "\n",
    "Remember that in this use case, it helps to explicitly tell Claude we want it to use a given tool:\n",
    "\n",
    "\n",
    ">Use the print_entities tool.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wikipedia summary example with more complex data\n",
    "\n",
    "Let's try another example that's a little more complex.  We'll use the Python `wikipedia` package to get entire Wikipedia page articles and pass them to Claude.  We'll use Claude to generate a response that includes:\n",
    "\n",
    "* The main subject of the article\n",
    "* A summary of the article\n",
    "* A list of keywords and topics mentioned in the article\n",
    "* A list of category classifications for the article (entertainment, politics, business, etc.) along with a classification score (i.e., how strongly the topic falls into that category)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we passed Claude the Wikipedia article about Walt Disney, we might expect a result like this: \n",
    "\n",
    "```json\n",
    "{\n",
    "  \"subject\": \"Walt Disney\",\n",
    "  \"summary\": \"Walter Elias Disney was an American animator, film producer, and entrepreneur. He was a pioneer of the American animation industry and introduced several developments in the production of cartoons. He held the record for most Academy Awards earned and nominations by an individual. He was also involved in the development of Disneyland and other theme parks, as well as television programs.\",\n",
    "  \"keywords\": [\n",
    "    \"Walt Disney\",\n",
    "    \"animation\",\n",
    "    \"film producer\",\n",
    "    \"entrepreneur\",\n",
    "    \"Disneyland\",\n",
    "    \"theme parks\",\n",
    "    \"television\"\n",
    "  ],\n",
    "  \"categories\": [\n",
    "    {\n",
    "      \"name\": \"Entertainment\",\n",
    "      \"score\": 0.9\n",
    "    },\n",
    "    {\n",
    "      \"name\": \"Business\",\n",
    "      \"score\": 0.7\n",
    "    },\n",
    "    {\n",
    "      \"name\": \"Technology\",\n",
    "      \"score\": 0.6\n",
    "    }\n",
    "  ]\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example implementation of a function that expects a Wikipedia page subject, finds the article, downloads the contents, passes it to Claude, and then prints out the resulting JSON data.  We use the same strategy of defining a tool to \"coach\" the shape of Claude's response.\n",
    "\n",
    "Note: make sure to `pip install wikipedia` if you don't have it on your machine!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import wikipedia\n",
    "\n",
    "#tool definition\n",
    "toolConfig = {\n",
    "  \"tools\": [\n",
    "    {\n",
    "      \"toolSpec\": {\n",
    "        \"name\": \"print_article_classification\",\n",
    "        \"description\": \"Prints the classification results.\",\n",
    "        \"inputSchema\": {\n",
    "          \"json\": {\n",
    "            \"type\": \"object\",\n",
    "            \"properties\": {\n",
    "              \"subject\": {\n",
    "                \"type\": \"string\",\n",
    "                \"description\": \"The overall subject of the article\"},\n",
    "              \"summary\": {\n",
    "                \"type\": \"string\",\n",
    "                \"description\": \"A paragaph summary of the article\"},\n",
    "              \"keywords\": {\n",
    "                \"type\": \"array\",\n",
    "                \"items\": {\n",
    "                  \"type\": \"string\",\n",
    "                  \"description\": \"List of keywords and topics in the article\"}\n",
    "              },\n",
    "              \"categories\": {\n",
    "                \"type\": \"array\",\n",
    "                \"items\": {\n",
    "                  \"type\": \"object\",\n",
    "                  \"properties\": {\n",
    "                    \"name\": {\"type\": \"string\", \"description\": \"The category name.\"},\n",
    "                    \"score\": {\"type\": \"number\", \"description\": \"The classification score for the category, ranging from 0.0 to 1.0.\"}\n",
    "                  },\n",
    "                  \"required\": [\"name\", \"score\"]\n",
    "                }\n",
    "              }\n",
    "            },\n",
    "            \"required\": [\"subject\", \"summary\", \"keywords\", \"categories\"]\n",
    "          }\n",
    "        }\n",
    "      }\n",
    "    }\n",
    "  ]\n",
    "}\n",
    "\n",
    "#The function that generates the json for a given article subject\n",
    "def generate_json_for_article(subject):\n",
    "    page = wikipedia.page(subject, auto_suggest=True)\n",
    "    query = f\"\"\"\n",
    "    <document>\n",
    "    {page.content}\n",
    "    </document>\n",
    "\n",
    "    Use the print_article_classification tool. Example categories are Politics, Sports, Technology, Entertainment, Business.\n",
    "    \"\"\"\n",
    "\n",
    "    converse_api_params = {\n",
    "        \"modelId\": \"anthropic.claude-3-haiku-20240307-v1:0\",\n",
    "        \"messages\": [{\"role\": \"user\", \"content\": [{\"text\": query}]}],\n",
    "        \"additionalModelRequestFields\": {\"max_tokens\": 4096},\n",
    "        \"toolConfig\": toolConfig\n",
    "    }\n",
    "\n",
    "    response = bedrock_client.converse(**converse_api_params)\n",
    "\n",
    "    json_classification = None\n",
    "    for content in response['output']['message']['content']:\n",
    "        if isinstance(content, dict) and 'toolUse' in content:\n",
    "            tool_use = content['toolUse']\n",
    "            if tool_use['name'] == \"print_article_classification\":\n",
    "                json_classification = tool_use['input']\n",
    "                break\n",
    "\n",
    "    if json_classification:\n",
    "        print(\"Text Classification (JSON):\")\n",
    "        print(json.dumps(json_classification, indent=2))\n",
    "    else:\n",
    "        print(\"No text classification found in the response.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "generate_json_for_article(\"Jeff Goldblum\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "generate_json_for_article(\"Octopus\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "generate_json_for_article(\"Herbert Hoover\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Use the above strategy to write a function called `translate` that takes a word or phrase and generates a structured JSON output that includes the original phrase in English and the translated phrase in Spanish, French, Japanese, and Arabic.\n",
    "\n",
    "Here is an example of how this should work:\n",
    "\n",
    "If we call this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "translate(\"how much does this cost\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 1.** You'll need to complete a toolConfig with a toolSpec for a tool we'll name \"translations_from_claude\". Here is the start of the toolSpec which includes English"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Here is a strater toolConfig we've added \"English\" for you.\n",
    "toolConfig = {\n",
    "  \"tools\": [\n",
    "    {\n",
    "      \"toolSpec\": {\n",
    "        \"name\": \"translations_from_claude\",\n",
    "        \"description\": \"The translations from Claude of a user provided phrase into English to Spanish, French, Japanese, and Arabic.\",\n",
    "        \"inputSchema\": {\n",
    "          \"json\": {\n",
    "            \"type\": \"object\",\n",
    "            \"properties\": {\n",
    "              \"english\": {\"type\": \"string\", \"description\": \"Your English translation of the provided content from the user\"},\n",
    "            },\n",
    "            \"required\": [\"english\"]\n",
    "          }\n",
    "        }\n",
    "      }\n",
    "    }\n",
    "  ],\n",
    "    \"toolChoice\": {\"tool\": {\"name\": \"translations_from_claude\"}}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "❓ If you want a hint related to your toolSpec, run the cell below!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(hints.exercise_10_2_2_toolSpec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 2.** Now you need to complete your \"translate\" function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def translate(query):\n",
    "    prompt = f\"\"\"\n",
    "    Translate phrase below from the user into Spanish, French, Japanese and Arabic.\n",
    "    Content to translate: '{query}'\n",
    "    \"\"\"\n",
    "\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "❓ If you want a hint related to your translate function, run the cell below!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(hints.exercise_10_2_2_translate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 3.** It's time to give our translate function a try."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "translate(\"how much does this cost\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We expect an output like this: \n",
    "\n",
    "```json\n",
    "{\n",
    "  \"english\": \"how much does this cost\",\n",
    "  \"spanish\": \"¿cuánto cuesta esto?\",\n",
    "  \"french\": \"combien ça coûte?\",\n",
    "  \"japanese\": \"これはいくらですか\",\n",
    "  \"arabic\": \"كم تكلفة هذا؟\"\n",
    "}\n",
    "```\n",
    "\n",
    "**NOTE: If you want to print your results, this line of code will help you print them out nicely:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(json.dumps(translations_from_claude, ensure_ascii=False, indent=2))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "",
   "name": ""
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}