notebooks/Mistral_Large_2_JSON_Mode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mistral Large 2 & Converse API JSON Mode Deep Dive\n",
    "\n",
    "Mistral Large 2 now offers a native JSON output mode. This feature allows developers to receive the model's responses in a structured, easy-to-read format that can be readily integrated into various applications and systems. With JSON being a widely adopted data exchange standard, this capability simplifies the process of working with the model's outputs, making it more accessible and practical for developers across different domains and use cases. \n",
    "\n",
    "\n",
    "The model is currently generally available for use on Amazon Bedrock, check out the [blog post](https://aws.amazon.com/blogs/machine-learning/mistral-large-2-is-now-available-in-amazon-bedrock/) for more info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "vscode": {
     "languageId": "plaintext"
    }
   },
   "source": [
    "In this notebook, we will be demonstrating JSON Output capabilities for two specific use cases:\n",
    "\n",
    "1. Entity Extraction Phase from Raw Text for Building Knowledge Graphs for Graph-based Retrieval-Augmented Generation (RAG)\n",
    "- Because it represents a trending pattern in retrieval augmented generation, where structured knowledge graphs enhance contextual understanding. \n",
    "- Automating the graph modeling process from raw text is essential yet often complex, and Mistral Large 2's native JSON output simplifies this by efficiently structuring extracted entities and relationships.\n",
    "\n",
    "2.  Integration with APIs or Other Web-based Services\n",
    "- Because It is a common approach for converting human text into structured queries. \n",
    "- This use case highlights how native JSON output reduces the need for intermediary data processing steps, streamlining the connection between natural language interfaces and APIs. \n",
    "- Additionally, using JSON enhances maintainability, making it easier to adapt to changes in API specifications.\n",
    "\n",
    "More details about generating JSON with the Amazon Bedrock Converse API can be found in this [blogpost](https://community.aws/content/2hWA16FSt2bIzKs0Z1fgJBwu589/generating-json-with-the-amazon-bedrock-converse-api?lang=en)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import necessary libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import boto3\n",
    "import json\n",
    "import networkx as nx \n",
    "\n",
    "session = boto3.Session(region_name=\"us-west-2\")\n",
    "bedrock_client = session.client(service_name='bedrock-runtime')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create Bedrock Client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "bedrock_client = boto3.client(service_name='bedrock-runtime', region_name=\"us-west-2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Instantiate model ids of mistral model being used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "mistral_large_2 = 'mistral.mistral-large-2407-v1:0'\n",
    "\n",
    "model_id = mistral_large_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Entity Extraction Phase from Raw Text\n",
    "\n",
    "Entity extraction is the process of identifying and extracting relevant entities (e.g., people, organizations, locations, dates, etc.) from raw text input. This capability is crucial in various natural language processing (NLP) tasks and applications, such as information retrieval, knowledge graph construction, and question answering systems.\n",
    "\n",
    "By leveraging Mistral Large 2's JSON output mode, developers can receive the extracted entities in a structured JSON format, making it easier to process and integrate them into downstream applications or pipelines.\n",
    "\n",
    "One notable example where entity extraction plays a vital role is in Graph-based Retrieval-Augmented Generation (RAG). In this technique, the extracted entities serve as the initial seed for querying external knowledge sources, such as knowledge graphs or databases, to retrieve additional information and augment the language model's knowledge. The structured JSON output from the entity extraction phase can be seamlessly ingested into the RAG pipeline, facilitating the construction or updating of knowledge graphs from raw text input."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To generate JSON with the Converse API, you need to define a toolSpec. In the following code, we define a schema for the entity extraction. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the tool configuration\n",
    "tool_list = [\n",
    "    {\n",
    "        \"toolSpec\": {\n",
    "            \"name\": \"entity_extractor\",\n",
    "            \"description\": \"Converts text into an entity json structure.\",\n",
    "            \"inputSchema\": {\n",
    "                \"json\": {\n",
    "                    \"type\": \"object\",\n",
    "                    \"properties\": {\n",
    "                        \"entity\": {\n",
    "                            \"type\": \"array\",\n",
    "                            \"items\": {\n",
    "                                \"type\": \"object\",\n",
    "                                \"properties\": {\n",
    "                                    \"entity_name\": {\n",
    "                                        \"type\": \"string\",\n",
    "                                        \"description\": \"The entity name.\"\n",
    "                                    },\n",
    "                                    \"entity_description\": {\n",
    "                                        \"type\": \"string\",\n",
    "                                        \"description\": \"The description of the entity\"\n",
    "                                    },\n",
    "                                    \"entity_type\": {\n",
    "                                        \"type\": \"string\",\n",
    "                                        \"description\": \"The entity type.\",\n",
    "                                        \"enum\": [\"People\", \"Organization\", \"Event\", \"Location\", \"Technology/Product\"]\n",
    "                                    }\n",
    "                                }\n",
    "                            }\n",
    "                        }\n",
    "                    },\n",
    "                    \"required\": [\n",
    "                        \"entity\"\n",
    "                    ]\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract entities from 500-word text about the history of the Internet and the World Wide Web:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "content = \"\"\"\n",
    "The history of the Internet and the World Wide Web:\n",
    "\n",
    "The Internet and the World Wide Web have revolutionized the way we communicate, access information, and conduct business. The origins of the Internet can be traced back to the 1960s when the Advanced Research Projects Agency (ARPA), a branch of the United States Department of Defense, initiated a research program to develop a decentralized communication network capable of withstanding potential nuclear attacks.\n",
    "\n",
    "This research led to the creation of ARPANET, the precursor to the modern Internet. Initially, ARPANET connected a few universities and research centers, allowing researchers to share data and resources. Over time, more institutions joined the network, and the concept of interconnecting networks emerged, laying the foundation for the Internet as we know it today.\n",
    "\n",
    "In the 1970s and 1980s, the Internet continued to evolve, with the development of key technologies such as the Transmission Control Protocol/Internet Protocol (TCP/IP), which standardized the way data is transmitted over the network. During this period, the Internet remained primarily a tool for researchers and academics.\n",
    "\n",
    "The true revolution came in 1989 when Tim Berners-Lee, a computer scientist at CERN (the European Organization for Nuclear Research), proposed the idea of the World Wide Web. Berners-Lee envisioned a system that would allow researchers to easily share and access information across the Internet. He developed the first web browser, server, and the Hypertext Transfer Protocol (HTTP), which enabled the retrieval and display of hypertext documents on the Internet.\n",
    "\n",
    "The World Wide Web quickly gained popularity, and in 1993, Marc Andreessen and his team at the National Center for Supercomputing Applications (NCSA) released Mosaic, the first widely-used graphical web browser. This user-friendly interface made the Web accessible to a broader audience, sparking a surge in Internet adoption and usage.\n",
    "\n",
    "As the Internet and the Web grew, various companies and organizations emerged to provide services and infrastructure. Internet Service Providers (ISPs) facilitated access to the Internet for individuals and businesses, while web hosting companies offered platforms for hosting websites and web applications.\n",
    "\n",
    "The rise of e-commerce in the late 1990s further accelerated the growth of the Internet and the Web. Companies like Amazon, eBay, and others pioneered online shopping and digital marketplaces, transforming the way we buy and sell goods and services.\n",
    "\n",
    "Today, the Internet and the World Wide Web have become integral parts of our daily lives. Social media platforms like Facebook, Twitter, and Instagram have revolutionized how we connect and share information. Online streaming services like Netflix and YouTube have disrupted traditional media and entertainment industries. Cloud computing and software-as-a-service (SaaS) models have transformed the way businesses operate and deliver services.\n",
    "\n",
    "Despite the immense progress and innovation, the Internet and the Web continue to evolve, driven by emerging technologies such as the Internet of Things (IoT), artificial intelligence, and blockchain. As we look to the future, these technologies promise to further revolutionize the way we live, work, and interact with the digital world.\n",
    "\"\"\"\n",
    "\n",
    "message = {\n",
    "    \"role\": \"user\",\n",
    "    \"content\": [\n",
    "        { \"text\": f\"<content>{content}</content>\" },\n",
    "        { \"text\": \"Please create a well-structured JSON object extracting the entities of the text. Create the JSON based on the content within the <content> tags.\" }\n",
    "    ],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bedrock client configuration\n",
    "response = bedrock_client.converse(\n",
    "    modelId=model_id,\n",
    "    messages=[message],\n",
    "    inferenceConfig={\n",
    "        \"maxTokens\": 4000,\n",
    "        \"temperature\": 0.2\n",
    "    },\n",
    "    toolConfig={\n",
    "        \"tools\": tool_list\n",
    "    }\n",
    ")\n",
    "\n",
    "response_message = response['output']['message']\n",
    "response_content_blocks = response_message['content']\n",
    "content_block = next((block for block in response_content_blocks if 'toolUse' in block), None)\n",
    "tool_use_block = content_block['toolUse']\n",
    "tool_result_dict = tool_use_block['input']\n",
    "entity_list= tool_result_dict\n",
    "print(json.dumps(entity_list, indent=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Entity schema\n",
    "To maintain consistency in extracting relationships between entities across chunks, we create a list of node names extracted in the previous invocation. Those start forming the extracted schema and serve as input parameters of the next toolspec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#extract entity name and type from the tool_result_dict variable\n",
    "schema = []\n",
    "for entity in tool_result_dict['entity']:\n",
    "    schema.append(entity['entity_name'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "schema"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now for each node, let's extract relationship.\n",
    "The following toolspec request the output to be a list of relionship between entities. Entities will be then ingested as edge in our graph database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the tool configuration\n",
    "tool_list = [\n",
    "    {\n",
    "        \"toolSpec\": {#‰\n",
    "            \"name\": \"relationship_extractor\",\n",
    "            \"description\": \"Converts text into an relationship json structure.\",\n",
    "            \"inputSchema\": {\n",
    "                \"json\": {\n",
    "                    \"type\": \"object\",\n",
    "                    \"edge\": {\n",
    "                        \"relationship\": {\n",
    "                            \"type\": \"array\",\n",
    "                            \"items\": {\n",
    "                                \"type\": \"object\",\n",
    "                                \"properties\": {\n",
    "                                    \"entity_1\": {\n",
    "                                        \"type\": \"string\",\n",
    "                                        \"description\": \"The name of the first entity.\",\n",
    "                                        \"enum\": schema\n",
    "                                    },\n",
    "                                    \"entity_2\": {\n",
    "                                        \"type\": \"string\",\n",
    "                                        \"description\": \"The name of the second entity\",\n",
    "                                        \"enum\": schema\n",
    "                                    },\n",
    "                                    \"relationship\": {\n",
    "                                        \"type\": \"string\",\n",
    "                                        \"description\": \"The relationship entity 1 has with entity 2.\"\n",
    "                                    }\n",
    "                                },\n",
    "                                \"required\": [\n",
    "                                    \"relationship\",\n",
    "                                    \"entity_1\",\n",
    "                                    \"entity_2\"\n",
    "                                ]\n",
    "                            }\n",
    "                        }\n",
    "                    },\n",
    "                    \"required\": [\n",
    "                        \"edge\"\n",
    "                    ]\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = {\n",
    "    \"role\": \"user\",\n",
    "    \"content\": [\n",
    "        { \"text\": f\"<content>{content}</content>\" },\n",
    "        { \"text\": f\"<entities>{schema}</entitoes>\" },\n",
    "        { \"text\": \"Please create a well-structured JSON object extracting the relationship of each entity in the tag <entities>.  Extract only clear and existing relationships from the text in the <content> tag. \" }\n",
    "    ],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bedrock client configuration\n",
    "response = bedrock_client.converse(\n",
    "    modelId=model_id,\n",
    "    messages=[message],\n",
    "    inferenceConfig={\n",
    "        \"maxTokens\": 4000,\n",
    "        \"temperature\": 0.1\n",
    "    },\n",
    "    toolConfig={\n",
    "        \"tools\": tool_list\n",
    "    }\n",
    ")\n",
    "\n",
    "response_message = response['output']['message']\n",
    "response_content_blocks = response_message['content']\n",
    "content_block = next((block for block in response_content_blocks if 'toolUse' in block), None)\n",
    "tool_use_block = content_block['toolUse']\n",
    "tool_result_dict = tool_use_block['input']\n",
    "print(json.dumps(tool_result_dict, indent=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize nodes (entities) and edges (relationships) extracted by the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = nx.Graph()\n",
    "G.add_nodes_from(schema)\n",
    "\n",
    "for relationship in tool_result_dict['edge']:\n",
    "    #check entity_1 and entity_2 exist in relationship\n",
    "    if 'entity_1' in relationship and 'entity_2' in relationship:\n",
    "        G.add_edge(relationship[\"entity_1\"], relationship[\"entity_2\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos = dict(zip(list(G.nodes()), nx.grid_2d_graph(3 * 3, 3 * 3)))\n",
    "nx.draw(G, pos = pos, ax = None, with_labels = True,font_size = 9, width=1, node_size = 400, node_color = 'lightgreen')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Integration with APIs and Web-Based Services\n",
    "\n",
    "In this use case, we'll explore how Mistral Large 2's JSON output mode can be leveraged to seamlessly integrate with external APIs and web-based services, focusing on a property management system. This capability is crucial for automating workflows, enhancing data processing, and creating more intelligent and responsive systems.\n",
    "\n",
    "We'll demonstrate this integration using two practical scenarios:\n",
    "1. Adding new properties to a database\n",
    "2. Searching for properties based on specific criteria\n",
    "\n",
    "What makes this example particularly interesting is that we'll provide the model with two different JSON schemas:\n",
    "1. A schema for adding a new property (addProperty)\n",
    "2. A schema for listing properties based on search criteria (listProperties)\n",
    "\n",
    "We'll let Mistral Large 2 decide which schema to use based on the content of the input text. This showcases the model's ability to not only structure data but also to choose the appropriate format based on the context of the request.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `addProperty` schema allows for the creation of new property listings with details such as type (House or Flat), description, location, size, number of bedrooms, and price. The `listProperties` schema enables searching for properties with filters like property type, location, minimum size, minimum number of bedrooms, and maximum price.\n",
    "\n",
    "\n",
    "Through this example, we'll see how Mistral Large 2's JSON output capabilities can enhance the efficiency and accuracy of API integrations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup and Configuration\n",
    "First, let's set up our environment and define the JSON schemas for our property management tools."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the tool configuration\n",
    "tool_list = [\n",
    "    {\n",
    "        \"toolSpec\": {\n",
    "            \"name\": \"addProperty\",\n",
    "            \"description\": \"Creates a new property in the store.\",\n",
    "            \"inputSchema\": {\n",
    "                \"json\": {\n",
    "                    \"type\": \"object\",\n",
    "                    \"properties\": {\n",
    "                        \"type\": {\n",
    "                            \"type\": \"string\",\n",
    "                            \"description\": \"Property type\",\n",
    "                            \"enum\": [\"House\", \"Flat\"]\n",
    "                        },\n",
    "                        \"description\": {\n",
    "                            \"type\": \"string\",\n",
    "                            \"description\": \"Description of the property\"\n",
    "                        },\n",
    "                        \"location\": {\n",
    "                            \"type\": \"string\",\n",
    "                            \"description\": \"Location of the property\"\n",
    "                        }, \n",
    "                        \"size\": {\n",
    "                            \"type\": \"integer\",\n",
    "                            \"description\": \"square meter of the property\"\n",
    "                        },\n",
    "                         \"bedrooms\": {\n",
    "                            \"type\": \"integer\",\n",
    "                            \"description\": \"number of bedroms\"\n",
    "                        },\n",
    "                         \"price\": {\n",
    "                            \"type\": \"integer\",\n",
    "                            \"description\": \"price of the property\"\n",
    "                        }\n",
    "                    },\n",
    "                    \"required\": [\n",
    "                        \"type\",\n",
    "                        \"location\",\n",
    "                        \"size\",\n",
    "                        \"price\"\n",
    "                    ]\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    },\n",
    "    {\n",
    "         \"toolSpec\": {\n",
    "            \"name\": \"listProperties\",\n",
    "            \"description\": \"Search all properties corresponding to the desired filters\",\n",
    "            \"inputSchema\": {\n",
    "                \"json\": {\n",
    "                    \"type\": \"object\",\n",
    "                    \"properties\": {\n",
    "                        \"type\": {\n",
    "                            \"type\": \"string\",\n",
    "                            \"description\": \"Property type\",\n",
    "                            \"enum\": [\"House\", \"Flat\"]\n",
    "                        },\n",
    "                        \"location\": {\n",
    "                            \"type\": \"string\",\n",
    "                            \"description\": \"Location of the property\"\n",
    "                        }, \n",
    "                        \"size\": {\n",
    "                            \"type\": \"integer\",\n",
    "                            \"description\": \"square meter of the property\"\n",
    "                        },\n",
    "                         \"minbedrooms\": {\n",
    "                            \"type\": \"integer\",\n",
    "                            \"description\": \"minimum number of bedrooms\"\n",
    "                        },\n",
    "                         \"maxprice\": {\n",
    "                            \"type\": \"integer\",\n",
    "                            \"description\": \"maximum price of the property\"\n",
    "                        }\n",
    "                    },\n",
    "                    \"required\": [\n",
    "                        \"type\",\n",
    "                        \"location\"\n",
    "                    ]\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 1: Adding a New Property\n",
    "In this example, we'll demonstrate how to use Mistral Large 2 to process a natural language request to add a new property and generate the appropriate JSON output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = \"\"\"\n",
    "Add a new house in Paris with 3 bedrooms, 120 square meters, priced at 500000 euros. It has a beautiful view of the Eiffel Tower.\n",
    "\"\"\"\n",
    "\n",
    "message = {\n",
    "    \"role\": \"user\",\n",
    "    \"content\": [\n",
    "        { \"text\": f\"<content>{content}</content>\" },\n",
    "        { \"text\": \"Please create a well-structured JSON object, ensuring proper nesting and organization of the data. Create the JSON based on the content within the <content> tags.\" }\n",
    "    ],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bedrock client configuration\n",
    "response = bedrock_client.converse(\n",
    "    modelId=model_id,\n",
    "    messages=[message],\n",
    "    inferenceConfig={\n",
    "        \"maxTokens\": 500,\n",
    "        \"temperature\": 0.1\n",
    "    },\n",
    "    toolConfig={\n",
    "        \"tools\": tool_list\n",
    "    }\n",
    ")\n",
    "\n",
    "response_message = response['output']['message']\n",
    "response_content_blocks = response_message['content']\n",
    "content_block = next((block for block in response_content_blocks if 'toolUse' in block), None)\n",
    "tool_use_block = content_block['toolUse']\n",
    "tool_result_dict = tool_use_block['input']\n",
    "\n",
    "print(\"tool used: \"+tool_use_block[\"name\"])\n",
    "print(json.dumps(tool_result_dict, indent=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 2: Searching for Properties\n",
    "Now, let's show how to use Mistral Large 2 to process a natural language query for property search and generate the appropriate JSON output.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "content = \"\"\"\n",
    "Find me apartments in London with at least 2 bedrooms and a maximum price of 400000 pounds.\n",
    "\"\"\"\n",
    "\n",
    "message = {\n",
    "    \"role\": \"user\",\n",
    "    \"content\": [\n",
    "        { \"text\": f\"<content>{content}</content>\" },\n",
    "        { \"text\": \"Please create a well-structured JSON object, ensuring proper nesting and organization of the data. Create the JSON based on the content within the <content> tags.\" }\n",
    "    ],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bedrock client configuration\n",
    "response = bedrock_client.converse(\n",
    "    modelId=model_id,\n",
    "    messages=[message],\n",
    "    inferenceConfig={\n",
    "        \"maxTokens\": 500,\n",
    "        \"temperature\": 0.1\n",
    "    },\n",
    "    toolConfig={\n",
    "        \"tools\": tool_list\n",
    "    }\n",
    ")\n",
    "\n",
    "response_message = response['output']['message']\n",
    "response_content_blocks = response_message['content']\n",
    "content_block = next((block for block in response_content_blocks if 'toolUse' in block), None)\n",
    "tool_use_block = content_block['toolUse']\n",
    "tool_result_dict = tool_use_block['input']\n",
    "\n",
    "print(\"tool used: \"+tool_use_block[\"name\"])\n",
    "print(json.dumps(tool_result_dict, indent=4))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "bedrock",
   "language": "python",
   "name": "python3"
  },
  "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.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}