Created
March 10, 2024 15:59
-
-
Save markomanninen/7c6e1e96faf0ec4382249e2131a9f1d0 to your computer and use it in GitHub Desktop.
Anthropic Claude Function Calling.ipynb
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| { | |
| "nbformat": 4, | |
| "nbformat_minor": 0, | |
| "metadata": { | |
| "colab": { | |
| "provenance": [], | |
| "authorship_tag": "ABX9TyO7EM6S9BTu651k7fvM2Ahr", | |
| "include_colab_link": true | |
| }, | |
| "kernelspec": { | |
| "name": "python3", | |
| "display_name": "Python 3" | |
| }, | |
| "language_info": { | |
| "name": "python" | |
| } | |
| }, | |
| "cells": [ | |
| { | |
| "cell_type": "markdown", | |
| "metadata": { | |
| "id": "view-in-github", | |
| "colab_type": "text" | |
| }, | |
| "source": [ | |
| "<a href=\"https://colab.research.google.com/gist/markomanninen/7c6e1e96faf0ec4382249e2131a9f1d0/anthropic-claude-function-calling.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "# Anthropic Claude Function Calling\n", | |
| "\n", | |
| "This document extends the notebook document: https://github.com/anthropics/anthropic-cookbook/blob/main/function_calling/function_calling.ipynb\n", | |
| "\n", | |
| "Marko T. Manninen © 03/2024\n", | |
| "\n", | |
| "---\n", | |
| "\n", | |
| "In this document, we delve into the logic of function calls within the realm of Large Language Models (LLMs), demonstrating a framework that's designed to be adaptable across various models, though specifically tailored for use with Anthropic's Claude Sonnet language model in this instance. Claude Sonnet, being more cost-effective than its counterpart, Opus, has been found to perform satisfactorily for the use case at hand. The task of writing function documentation and Colab notebook texts was assigned to ChatGPT, aimed at creating a cohesive and comprehensible guide.\n", | |
| "\n", | |
| "To fully utilize this notebook, you'll need to provide an Anthropic API key. By the document's conclusion, you'll have the opportunity to test out your own prompts, exploring the capabilities and functionalities firsthand. For those interested in customizing the system further by adding new callable functions, the process involves defining these functions in Python, specifying their reference names/types `<xs:complexType name=\"OwnType\">` and the arguments they accept within the schema file `function_call_schema`.\n", | |
| "\n", | |
| "The initial learning curve might be steep as you navigate through understanding how language models can be integrated with native programming functions, translating both the given prompts and the results. However, mastering this concept opens up new avenues of knowledge on the symbiosis between language models and native applications, enhancing your grasp on how to leverage AI in interpreting and executing complex tasks." | |
| ], | |
| "metadata": { | |
| "id": "V1n0wV8G0l0J" | |
| } | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Install\n", | |
| "\n", | |
| "To prepare for utilizing Anthropic's tools or libraries in this Colab notebook, the first step involves setting up the necessary software environment. This setup includes installing the `anthropic` Python package, which provides access to functionalities or models developed by Anthropic. This package installation is crucial for leveraging the cutting-edge AI technologies or tools that Anthropic offers, ensuring that the notebook has the required dependencies to run any subsequent code involving Anthropic's AI models or utilities efficiently. The following command installs the `anthropic` package using pip, Python's package installer, guaranteeing that the latest version of the package is added to the notebook's environment." | |
| ], | |
| "metadata": { | |
| "id": "7OrMvXGlyoDL" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "!pip install anthropic" | |
| ], | |
| "metadata": { | |
| "id": "mbjpnx3xA9gI" | |
| }, | |
| "execution_count": null, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Import and Configure\n", | |
| "\n", | |
| "This block of code is designed for integrating various Python libraries and functionalities into your Colab notebook, focusing particularly on XML parsing, secure random string generation, regular expressions, interaction with Anthropic's AI models, and accessing user data stored in Google Colab. Here's a breakdown of its components:\n", | |
| "\n", | |
| "1. **XML Parsing**: `xml.etree.ElementTree` and `lxml.etree` are imported for parsing and manipulating XML data. While `xml.etree.ElementTree` is a built-in Python library suitable for most XML tasks, `lxml.etree` offers more advanced features and better performance for complex XML processing.\n", | |
| "\n", | |
| "2. **Utilities**:\n", | |
| " - The `operator` module provides a set of efficient functions corresponding to the intrinsic operators of Python. For example, you can use these functions for mathematical operations, string comparisons, and logical operations in a functional programming style.\n", | |
| " - The `secrets` module is used for generating cryptographically strong random numbers and strings, which is crucial for security-sensitive applications.\n", | |
| " - The `string` module includes a collection of string constants, such as ASCII letters and digits, which can be used in conjunction with `secrets` for generating secure random strings.\n", | |
| " - The `re` module allows for regular expression operations, enabling you to perform complex pattern matching and manipulation of text data.\n", | |
| "\n", | |
| "3. **Anatropic AI Integration**:\n", | |
| " - The `anthropic` library is imported to enable interaction with Anthropic's AI models. The client is initialized with an API key retrieved from the Colab's user data, allowing secure access to Anthropic's AI services.\n", | |
| " - The `MODEL_NAME` variable specifies the name of the Anthropic AI model you intend to use. It's set to `\"claude-3-sonnet-20240229\"` as an example, indicating a specific version of the Claude-3 model designed for generating sonnets. Note that the comment suggests an alternative model, `\"claude-3-opus-20240229\"`, which you might use for different AI tasks.\n", | |
| "\n", | |
| "4. **Google Colab User Data**:\n", | |
| " - The code snippet `from google.colab import userdata` imports the `userdata` module from Google Colab's library, which provides a method to access user-specific data, such as API keys stored in the Colab environment. This feature is utilized to securely fetch the `ANTHROPIC_API_KEY`, demonstrating a way to integrate secure API usage within a Colab notebook.\n", | |
| " \n", | |
| "\n", | |
| "This setup ensures a versatile environment in your Colab notebook, ready to handle a wide range of tasks from XML processing to secure interaction with AI models provided by Anthropic, all while maintaining best practices for security and performance." | |
| ], | |
| "metadata": { | |
| "id": "CrkQ9ePzyxqT" | |
| } | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "### API Key from Colab Document Secrets\n", | |
| "\n", | |
| "" | |
| ], | |
| "metadata": { | |
| "id": "ubCdZsaD9r0u" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "import xml.etree.ElementTree as ET\n", | |
| "from lxml import etree\n", | |
| "import operator\n", | |
| "import secrets\n", | |
| "import string\n", | |
| "import re\n", | |
| "import anthropic\n", | |
| "\n", | |
| "# User your preferred way of setting up api key\n", | |
| "from google.colab import userdata\n", | |
| "\n", | |
| "client = anthropic.Anthropic(\n", | |
| " # defaults to os.environ.get(\"ANTHROPIC_API_KEY\")\n", | |
| " #api_key=\"sk-...\",\n", | |
| " api_key=userdata.get('ANTHROPIC_API_KEY'),\n", | |
| ")\n", | |
| "\n", | |
| "MODEL_NAME = \"claude-3-sonnet-20240229\" # claude-3-opus-20240229" | |
| ], | |
| "metadata": { | |
| "id": "Dkp6LN2myyB5" | |
| }, | |
| "execution_count": 2, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Functions\n", | |
| "\n", | |
| "This code snippet encompasses a comprehensive suite of functions designed to validate XML documents against XML Schemas (XSD), evaluate arithmetic expressions represented in XML, generate secure random strings, and construct prompts for the Claude model by Anthropic. Each function is crafted to perform a specific task within this ecosystem, working together to process and evaluate XML-based input, generate dynamic responses based on predefined operations, and interact with AI models through the Anthropic API. The structure allows for flexible manipulation of XML data, secure randomization, and dynamic interaction with AI models, showcasing an advanced integration of XML processing, secure programming practices, and AI-driven automation within a Python environment.\n", | |
| "\n", | |
| "1. **validate_xml_against_xsd**: Validates an XML document against an XML Schema, returning `True` if the document adheres to the schema or `False` if it doesn't, while also printing any errors encountered during the validation process.\n", | |
| "\n", | |
| "2. **construct_format_tool_for_claude_prompt**: Creates a formatted XML-like string that describes a tool or function, including its title, name, description, and parameters, intended to structure information for the Claude model.\n", | |
| "\n", | |
| "3. **construct_tool_use_system_prompt**: Compiles a system prompt for Claude, integrating instructions, available tools, and parameter schemas into a cohesive prompt that outlines how tools can be invoked within the system.\n", | |
| "\n", | |
| "4. **construct_successful_function_run_injection_prompt**: Generates an XML-like summary of the results from invoking various tools, formatting the output of each tool's operation for clear presentation.\n", | |
| "\n", | |
| "5. **parse_function_call**: Extracts the `<function_calls>` section from a provided XML or text input, facilitating the isolation of specific sections for further processing or validation.\n", | |
| "\n", | |
| "6. **validate_and_create_assistant_message**: Validates a given XML input against an XSD schema and, if valid, processes the specified operations in the XML, constructing a summary message of the results.\n", | |
| "\n", | |
| "7. **prompt_claude**: Interfaces with the Anthropic API to send a prompt to the Claude model, retrieving and returning the generated response based on given parameters and context.\n", | |
| "\n", | |
| "8. **function_calling**: Orchestrates the creation and processing of function calls based on user prompts, generating XML for function invocation, validating it, and constructing a final message using responses from the Claude model." | |
| ], | |
| "metadata": { | |
| "id": "aBX8qluT1ePL" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "def validate_xml_against_xsd(xml_input, xsd_input):\n", | |
| " \"\"\"\n", | |
| " Validates an XML document against an XML Schema.\n", | |
| "\n", | |
| " Args:\n", | |
| " xml_input (str): A string representation of the XML document.\n", | |
| " xsd_input (str): A string representation of the XML Schema (XSD).\n", | |
| "\n", | |
| " Returns:\n", | |
| " bool: True if the XML document is valid against the schema, False otherwise.\n", | |
| " \"\"\"\n", | |
| " try:\n", | |
| " schema_root = etree.XML(xsd_input)\n", | |
| " schema = etree.XMLSchema(schema_root)\n", | |
| " xml_parser = etree.XMLParser(schema=schema)\n", | |
| " etree.fromstring(xml_input, xml_parser)\n", | |
| " return True\n", | |
| " except etree.XMLSchemaError as e:\n", | |
| " print(f\"XML schema validation error: {e}\")\n", | |
| " return False\n", | |
| " except etree.XMLSyntaxError as e:\n", | |
| " print(f\"XML syntax error: {e}\")\n", | |
| " print(xml_input)\n", | |
| " return False\n", | |
| "\n", | |
| "def construct_format_tool_for_claude_prompt(title, name, description, operation_type):\n", | |
| " \"\"\"\n", | |
| " Constructs a formatted tool description for Claude's prompt, encapsulating essential information about the tool within an XML-like structure.\n", | |
| "\n", | |
| " Args:\n", | |
| " title (str): The title of the tool, providing a brief headline or identifier.\n", | |
| " name (str): The name of the tool, typically used as a unique identifier.\n", | |
| " description (str): A description of the tool, detailing its purpose and use.\n", | |
| " operation_type (str): A string containing a reference to a parameter schema that details the inputs the tool accepts.\n", | |
| "\n", | |
| " Returns:\n", | |
| " str: The formatted tool description in an XML-like string, ready for inclusion in Claude's prompts or documentation.\n", | |
| " \"\"\"\n", | |
| " return (\n", | |
| " \"<tool_description>\\n\"\n", | |
| " f\"<tool_title>{title}</tool_title>\\n\"\n", | |
| " f\"<tool_name>{name}</tool_name>\\n\"\n", | |
| " \"<description>\\n\"\n", | |
| " f\"{description}\\n\"\n", | |
| " \"</description>\\n\"\n", | |
| " f\"<operation type=\\\"{operation_type}\\\"/>\\n\"\n", | |
| " \"</tool_description>\"\n", | |
| " )\n", | |
| "\n", | |
| "def construct_tool_use_system_prompt(tools, schemas):\n", | |
| " \"\"\"\n", | |
| " Constructs the system prompt for Claude, highlighting the available tools and how to invoke them.\n", | |
| " This prompt includes a detailed list of tools, showcasing how each can be called, followed by the schemas\n", | |
| " detailing the structure and parameters for each tool's invocation.\n", | |
| "\n", | |
| " Args:\n", | |
| " tools (list): A list of formatted tool descriptions, each providing detailed information about a tool,\n", | |
| " including its title, name, description, and parameterization.\n", | |
| " schemas (str): A string containing XML-formatted descriptions of the parameters schemas for all tools,\n", | |
| " providing details on how to correctly format function calls for each tool.\n", | |
| "\n", | |
| " Returns:\n", | |
| " str: The system prompt for Claude, integrating instructions for tool invocation, a list of available tools,\n", | |
| " and detailed schemas for tool use.\n", | |
| " \"\"\"\n", | |
| " return ''.join((\n", | |
| " \"In this environment you have access to a set of tools you can use to answer the user's question.\\n\",\n", | |
| " \"\\n\",\n", | |
| " \"You may call them like this:\\n\",\n", | |
| " \"<function_calls>\\n\",\n", | |
| " \"<invoke>\\n\",\n", | |
| " \"<tool_name>$TOOL_NAME</tool_name>\\n\",\n", | |
| " \"$PARAMETERS\\n\",\n", | |
| " \"</invoke>\\n\",\n", | |
| " \"</function_calls>\\n\",\n", | |
| " \"\\n\",\n", | |
| " \"Here are the tools available:\\n\",\n", | |
| " \"<tools>\\n\"\n", | |
| " + '\\n'.join([tool for tool in tools]) +\n", | |
| " \"\\n</tools>\\n\",\n", | |
| " \"\\n<!-- Schemas -->\\n\",\n", | |
| " schemas\n", | |
| " ))\n", | |
| "\n", | |
| "def construct_successful_function_run_injection_prompt(invoke_results):\n", | |
| " \"\"\"\n", | |
| " Constructs an XML-like string that summarizes the results of tool invocations.\n", | |
| "\n", | |
| " Args:\n", | |
| " invoke_results (list of dict): A list where each dictionary contains 'tool_name'\n", | |
| " and 'tool_result' keys representing the name of the\n", | |
| " tool invoked and its output, respectively.\n", | |
| "\n", | |
| " Returns:\n", | |
| " str: A structured XML-like string that encapsulates each tool's invocation results.\n", | |
| " \"\"\"\n", | |
| " # Formatting each tool's results into XML structure\n", | |
| " constructed_prompt = \"<function_results>\\n\" + '\\n'.join(\n", | |
| " f\"<result>\\n<tool_name>{res['tool_name']}</tool_name>\\n<stdout>\\n{res['tool_result']}\\n</stdout>\\n</result>\"\n", | |
| " for res in invoke_results\n", | |
| " ) + \"\\n</function_results>\"\n", | |
| "\n", | |
| " return constructed_prompt\n", | |
| "\n", | |
| "def parse_function_call(xml_input):\n", | |
| " \"\"\"\n", | |
| " Extracts the <function_calls> section from a provided XML or text input.\n", | |
| "\n", | |
| " Args:\n", | |
| " xml_input (str): The XML or string input from which to extract the <function_calls> section.\n", | |
| "\n", | |
| " Returns:\n", | |
| " str: The extracted <function_calls> section, if found. Otherwise, returns None.\n", | |
| " \"\"\"\n", | |
| " # Using regex to find the <function_calls> XML content\n", | |
| " xml_content_match = re.search(r\"(<function_calls>.+?</function_calls>)\", xml_input, re.DOTALL)\n", | |
| "\n", | |
| " if xml_content_match:\n", | |
| " # Returning the matched <function_calls> content\n", | |
| " return xml_content_match.group(1)\n", | |
| " else:\n", | |
| " # Handling cases where no <function_calls> content is found\n", | |
| " print(\"No XML content found.\")\n", | |
| " return None\n", | |
| "\n", | |
| "def validate_and_create_assistant_message(xml_input, xsd_input):\n", | |
| " \"\"\"\n", | |
| " Validates given XML input against an XSD schema, and if valid, evaluates the operations\n", | |
| " specified in the XML and constructs a message summarizing the results.\n", | |
| "\n", | |
| " Args:\n", | |
| " xml_input (str): XML input string containing function calls.\n", | |
| " xsd_input (str): XSD schema string against which to validate the XML input.\n", | |
| "\n", | |
| " Returns:\n", | |
| " str/bool: Constructed message summarizing the invocation results if the XML is valid;\n", | |
| " otherwise, returns False.\n", | |
| " \"\"\"\n", | |
| " # Extracting <function_calls> section from the input\n", | |
| " xml_content = parse_function_call(xml_input)\n", | |
| "\n", | |
| " # Validate the extracted XML content against the XSD schema\n", | |
| " if xml_content and validate_xml_against_xsd(xml_content, xsd_input):\n", | |
| " # If valid, construct and return the summary message\n", | |
| " return xml_content + \"\\n\" + construct_successful_function_run_injection_prompt(\n", | |
| " extract_and_evaluate_operations(xml_content)\n", | |
| " )\n", | |
| " else:\n", | |
| " # Return False if the XML is invalid or no <function_calls> section is found\n", | |
| " return False\n", | |
| "\n", | |
| "def prompt_claude(client, messages=[], system_prompt=\"\", model=\"claude-3-sonnet-20240229\", temperature=0, max_tokens=255):\n", | |
| " \"\"\"\n", | |
| " Sends a prompt to Claude API and retrieves the generated response.\n", | |
| "\n", | |
| " Args:\n", | |
| " client: The API client configured to interact with Claude.\n", | |
| " messages (list): List of previous messages and responses to provide context.\n", | |
| " system_prompt (str): The system prompt or instructions for Claude.\n", | |
| " model (str): The model version to use for generating responses.\n", | |
| " temperature (float): Controls randomness in the response generation.\n", | |
| " max_tokens (int): The maximum length of the model's response.\n", | |
| "\n", | |
| " Returns:\n", | |
| " str: The text of the first response from Claude, or a message indicating\n", | |
| " an issue with obtaining a valid response.\n", | |
| " \"\"\"\n", | |
| " try:\n", | |
| " # Making an API call to the Claude model with the provided parameters\n", | |
| " result = client.messages.create(\n", | |
| " model=model,\n", | |
| " temperature=temperature,\n", | |
| " max_tokens=max_tokens,\n", | |
| " messages=messages,\n", | |
| " system=system_prompt\n", | |
| " )\n", | |
| "\n", | |
| " # Check if the response has the expected structure and content\n", | |
| " if result and result.content and len(result.content) > 0:\n", | |
| " return result.content[0].text\n", | |
| " else:\n", | |
| " # Return a placeholder or error message if the expected content isn't found\n", | |
| " return \"Unable to retrieve a valid response from the model.\"\n", | |
| " except Exception as e:\n", | |
| " # Handle any errors that may occur during the API call or response processing\n", | |
| " return f\"An error occurred while fetching the response: {str(e)}\"\n", | |
| "\n", | |
| "def function_calling(client, user_prompt, tools, function_call_schema, debug_xmls = False):\n", | |
| " \"\"\"\n", | |
| " Orchestrates the creation and processing of function calls within a system that utilizes Claude\n", | |
| " for generating and validating function call XML based on user prompts.\n", | |
| "\n", | |
| " Args:\n", | |
| " client: The API client configured to interact with Claude.\n", | |
| " user_prompt (str): The initial prompt from the user, describing their request.\n", | |
| " tools (list): A list of formatted tool descriptions for use in the system prompt.\n", | |
| " function_call_schema (str): The XML Schema Definition (XSD) as a string, against which generated function call XML will be validated.\n", | |
| "\n", | |
| " Returns:\n", | |
| " str: The final message from Claude after processing the function call, or an error message if validation fails.\n", | |
| " \"\"\"\n", | |
| " # Construct the system prompt from the tools and schema\n", | |
| " system_prompt = construct_tool_use_system_prompt(tools, function_call_schema)\n", | |
| "\n", | |
| " if debug_xmls:\n", | |
| " print(f\"\\n\\nSystem prompt: {system_prompt}\")\n", | |
| "\n", | |
| " # Create the user message to send to Claude\n", | |
| " user_message = {\n", | |
| " \"role\": \"user\",\n", | |
| " \"content\": user_prompt\n", | |
| " }\n", | |
| "\n", | |
| " # Generate the XML for the function call based on the user's prompt\n", | |
| " function_call_input = prompt_claude(\n", | |
| " client,\n", | |
| " [user_message],\n", | |
| " system_prompt + \"\\nGenerate only XML.\"\n", | |
| " )\n", | |
| "\n", | |
| " # Validate the generated XML against the schema and create the assistant message\n", | |
| " assistant_message_content = validate_and_create_assistant_message(function_call_input, function_call_schema)\n", | |
| "\n", | |
| " if assistant_message_content:\n", | |
| "\n", | |
| " if debug_xmls:\n", | |
| " print(f\"\\n\\nAssistant message: {assistant_message_content}\")\n", | |
| "\n", | |
| " # If validation succeeds, prepare the assistant message for final processing\n", | |
| " assistant_message = {\n", | |
| " \"role\": \"assistant\",\n", | |
| " \"content\": assistant_message_content\n", | |
| " }\n", | |
| "\n", | |
| " # Generate the final message using both the user and assistant messages\n", | |
| " return prompt_claude(\n", | |
| " client,\n", | |
| " [user_message, assistant_message],\n", | |
| " system_prompt\n", | |
| " )\n", | |
| " else:\n", | |
| " # Handle cases where validation fails or no valid function call XML is generated\n", | |
| " return \"Final message could not be retrieved due to validation failure or empty function call XML.\"" | |
| ], | |
| "metadata": { | |
| "id": "ykOLyJoXK3Zy" | |
| }, | |
| "execution_count": 3, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "### Custom functions for Tools\n", | |
| "\n", | |
| "Native Python functions are defined here to be referenced in the function calling tool chain by Claude: `do_pairwise_arithmetic` and `do_random_string`.\n", | |
| "\n", | |
| "1. **evaluate_expression**: Recursively evaluates an arithmetic expression represented in XML, supporting basic operations like addition, subtraction, multiplication, and division. It navigates through nested XML elements to compute the final result of the expression.\n", | |
| "\n", | |
| "2. **generate_random_string**: Generates a secure random string of specified length, combining uppercase and lowercase letters with digits, suitable for use cases requiring random identifiers or tokens.\n", | |
| "\n", | |
| "3. **handle_arithmetic_operation**: Extracts and evaluates an arithmetic operation defined within an XML `<invoke>` element, using the `evaluate_expression` function to compute its result.\n", | |
| "\n", | |
| "4. **handle_random_string**: Generates a random string based on a specified length found within an XML `<invoke>` element, ensuring the length falls within a valid range before generating the string.\n", | |
| "\n", | |
| "5. **extract_and_evaluate_operations**: Parses an XML string to extract `<invoke>` elements, determining the type of operation (arithmetic or random string generation) to perform, evaluates these operations, and collects their results." | |
| ], | |
| "metadata": { | |
| "id": "0-tYHfonCGNp" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "#####################################\n", | |
| "# Mapping for arithmetic operations #\n", | |
| "#####################################\n", | |
| "\n", | |
| "operation_mapping = {\n", | |
| " '+': operator.add,\n", | |
| " '-': operator.sub,\n", | |
| " '*': operator.mul,\n", | |
| " '/': operator.truediv,\n", | |
| "}\n", | |
| "\n", | |
| "def evaluate_expression(element):\n", | |
| " \"\"\"\n", | |
| " Recursively evaluates an arithmetic expression represented as XML elements.\n", | |
| "\n", | |
| " This function supports 'operation' elements, which specify an arithmetic operation\n", | |
| " (addition, subtraction, multiplication, division) and 'number' elements as operands.\n", | |
| " Each 'operation' must have exactly two operands, which can be 'number' elements or\n", | |
| " nested 'operation' elements.\n", | |
| "\n", | |
| " Args:\n", | |
| " element (xml.etree.ElementTree.Element): An XML element representing either an\n", | |
| " 'operation' or a 'number'.\n", | |
| "\n", | |
| " Returns:\n", | |
| " int: The result of the evaluated expression.\n", | |
| "\n", | |
| " Raises:\n", | |
| " ValueError: If an unsupported operation is encountered or if the operation does not\n", | |
| " have exactly two operands.\n", | |
| " \"\"\"\n", | |
| " # Check if the current element is an 'operation'\n", | |
| " if element.tag == 'operation':\n", | |
| " # Retrieve the operation type (e.g., '+', '-', '*', '/')\n", | |
| " operation = element.attrib['operator']\n", | |
| " # Map the operation type to a corresponding Python function\n", | |
| " operation_func = operation_mapping.get(operation)\n", | |
| "\n", | |
| " # Raise an error if the operation is not supported\n", | |
| " if not operation_func:\n", | |
| " raise ValueError(f\"Operation {operation} not supported.\")\n", | |
| "\n", | |
| " # Recursively evaluate the operands of the operation\n", | |
| " operands = [evaluate_expression(child) for child in element]\n", | |
| "\n", | |
| " # Ensure that each operation has exactly two operands\n", | |
| " if len(operands) != 2:\n", | |
| " raise ValueError(\"Each operation must have exactly two operands.\")\n", | |
| "\n", | |
| " # Perform the operation with the evaluated operands and return the result\n", | |
| " return operation_func(*operands)\n", | |
| "\n", | |
| " # Check if the current element is a 'number'\n", | |
| " elif element.tag == 'number':\n", | |
| " # Return the integer value of the number element\n", | |
| " return int(element.text)\n", | |
| "\n", | |
| " # Raise an error if the element is neither an 'operation' nor a 'number'\n", | |
| " else:\n", | |
| " raise ValueError(f\"Unsupported element: {element.tag}\")\n", | |
| "\n", | |
| "def generate_random_string(length):\n", | |
| " \"\"\"\n", | |
| " Generates a secure random string of the specified length, using a combination\n", | |
| " of uppercase and lowercase letters, along with digits.\n", | |
| "\n", | |
| " Args:\n", | |
| " length (int): The length of the random string to be generated. Must be\n", | |
| " a non-negative integer.\n", | |
| "\n", | |
| " Returns:\n", | |
| " str: A random string of the specified length.\n", | |
| " \"\"\"\n", | |
| " # Define the alphabet: includes both uppercase and lowercase letters, and digits\n", | |
| " alphabet = string.ascii_letters + string.digits\n", | |
| "\n", | |
| " # Generate a random string of the given length\n", | |
| " return ''.join(secrets.choice(alphabet) for _ in range(length))\n", | |
| "\n", | |
| "def handle_arithmetic_operation(invoke):\n", | |
| " \"\"\"\n", | |
| " Handles the arithmetic operation for a given invoke element.\n", | |
| " \"\"\"\n", | |
| " operation_element = invoke.find('.//operation')\n", | |
| " if operation_element is not None:\n", | |
| " try:\n", | |
| " return evaluate_expression(operation_element)\n", | |
| " except ValueError as e:\n", | |
| " print(f\"Invalid value: {e}\")\n", | |
| " else:\n", | |
| " print(\"No operation found within <invoke>.\")\n", | |
| " return None\n", | |
| "\n", | |
| "def handle_random_string(invoke):\n", | |
| " \"\"\"\n", | |
| " Handles the generation of a random string for a given invoke element.\n", | |
| " \"\"\"\n", | |
| " random_string_element = invoke.find('.//randomstring')\n", | |
| " if random_string_element is not None and 'length' in random_string_element.attrib:\n", | |
| " try:\n", | |
| " length = int(random_string_element.attrib['length'])\n", | |
| " if 1 <= length <= 1000:\n", | |
| " return generate_random_string(length)\n", | |
| " else:\n", | |
| " print(\"Random string length must be between 1 and 1000.\")\n", | |
| " except ValueError as e:\n", | |
| " print(f\"Invalid length value: {e}\")\n", | |
| " else:\n", | |
| " print(\"Random string length attribute is missing or invalid.\")\n", | |
| " return None\n", | |
| "\n", | |
| "def extract_and_evaluate_operations(xml_string):\n", | |
| " \"\"\"\n", | |
| " Extracts and evaluates operations from an XML string, handling arithmetic and random string generation.\n", | |
| " \"\"\"\n", | |
| " root = ET.fromstring(xml_string)\n", | |
| " invoke_results = []\n", | |
| "\n", | |
| " for invoke in root.findall('.//invoke'):\n", | |
| " tool_name = invoke.find('tool_name').text\n", | |
| " result = None\n", | |
| "\n", | |
| " if tool_name == 'do_pairwise_arithmetic':\n", | |
| " result = handle_arithmetic_operation(invoke)\n", | |
| " elif tool_name == 'do_random_string':\n", | |
| " result = handle_random_string(invoke)\n", | |
| " else:\n", | |
| " print(f\"Unsupported tool name: {tool_name}\")\n", | |
| "\n", | |
| " if result is not None:\n", | |
| " invoke_results.append({'tool_name': tool_name, 'tool_result': result})\n", | |
| "\n", | |
| " return invoke_results" | |
| ], | |
| "metadata": { | |
| "id": "Xfp8URvYCDYh" | |
| }, | |
| "execution_count": 4, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Function Call Schema\n", | |
| "\n", | |
| "This XML Schema Definition (XSD) specifies the structure for an XML document that represents function calls, particularly focusing on arithmetic operations and the generation of random strings. The schema is designed to validate XML documents that describe these operations in a structured and type-safe manner. Here's a brief overview of each component within the schema:\n", | |
| "\n", | |
| "- **OperatorType**: A simple type definition that restricts the operator attribute to one of four arithmetic operations: addition (`+`), subtraction (`-`), multiplication (`*`), or division (`/`).\n", | |
| "\n", | |
| "- **NumberType**: A complex type that extends `xs:decimal` to include both integers and floating-point numbers, used for representing numeric operands in operations.\n", | |
| "\n", | |
| "- **OperationType**: A recursive complex type for the `operation` element, allowing it to contain either `number` elements or nested `operation` elements, each of which requires an `operator` attribute of the `OperatorType`.\n", | |
| "\n", | |
| "- **RandomType**: A complex type designed for elements that specify the generation of random strings, potentially including a `length` attribute to define the length of the generated string.\n", | |
| "\n", | |
| "- **InvokeType**: A complex type for the `invoke` element, which acts as a container for specifying a function call. It includes a mandatory `tool_name` element and optional `operation` and `randomstring` elements, allowing for the definition of both arithmetic operations and random string generation requests.\n", | |
| "\n", | |
| "- **FunctionCallsType**: Defines the structure for the `function_calls` element, which can contain one or more `invoke` elements. This setup enables the representation of multiple function invocations within a single XML document.\n", | |
| "\n", | |
| "- **Root Element**: The schema establishes `function_calls` as the root element, expecting it to conform to the `FunctionCallsType`.\n", | |
| "\n", | |
| "This schema effectively outlines the expected format for XML documents used in this system, ensuring that any XML document used for invoking functions like arithmetic operations or random string generation is both structured and validated against these definitions." | |
| ], | |
| "metadata": { | |
| "id": "GYvQOrQM18RW" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "function_call_schema = \"\"\"\n", | |
| "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">\n", | |
| "\n", | |
| " <!-- Simple type for the operator attribute -->\n", | |
| " <xs:simpleType name=\"OperatorType\">\n", | |
| " <xs:restriction base=\"xs:string\">\n", | |
| " <xs:enumeration value=\"+\"/>\n", | |
| " <xs:enumeration value=\"-\"/>\n", | |
| " <xs:enumeration value=\"*\"/>\n", | |
| " <xs:enumeration value=\"/\"/>\n", | |
| " </xs:restriction>\n", | |
| " </xs:simpleType>\n", | |
| "\n", | |
| " <!-- Complex type for the number element to include both integers and floats -->\n", | |
| " <xs:complexType name=\"NumberType\">\n", | |
| " <xs:simpleContent>\n", | |
| " <xs:extension base=\"xs:decimal\"/>\n", | |
| " </xs:simpleContent>\n", | |
| " </xs:complexType>\n", | |
| "\n", | |
| " <!-- Recursive complex type for the operation element -->\n", | |
| " <xs:complexType name=\"OperationType\">\n", | |
| " <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">\n", | |
| " <xs:element name=\"number\" type=\"NumberType\"/>\n", | |
| " <xs:element name=\"operation\" type=\"OperationType\"/>\n", | |
| " </xs:choice>\n", | |
| " <xs:attribute name=\"operator\" type=\"OperatorType\" use=\"required\"/>\n", | |
| " </xs:complexType>\n", | |
| "\n", | |
| " <!-- Definition for RandomType -->\n", | |
| " <xs:complexType name=\"RandomType\">\n", | |
| " <xs:simpleContent>\n", | |
| " <xs:extension base=\"xs:string\">\n", | |
| " <xs:attribute name=\"length\" type=\"xs:integer\" use=\"optional\"/>\n", | |
| " </xs:extension>\n", | |
| " </xs:simpleContent>\n", | |
| " </xs:complexType>\n", | |
| "\n", | |
| " <!-- Add more types to here -->\n", | |
| "\n", | |
| " <!-- Complex type for the invoke element with optional operation and randomstring -->\n", | |
| " <xs:complexType name=\"InvokeType\">\n", | |
| " <xs:sequence>\n", | |
| " <xs:element name=\"tool_name\" type=\"xs:string\"/>\n", | |
| " <xs:element name=\"operation\" type=\"OperationType\" minOccurs=\"0\"/>\n", | |
| " <xs:element name=\"randomstring\" type=\"RandomType\" minOccurs=\"0\"/>\n", | |
| " <!-- Add more type references to here -->\n", | |
| " </xs:sequence>\n", | |
| " </xs:complexType>\n", | |
| "\n", | |
| " <!-- Complex type for the function_calls element -->\n", | |
| " <xs:complexType name=\"FunctionCallsType\">\n", | |
| " <xs:sequence>\n", | |
| " <xs:element name=\"invoke\" type=\"InvokeType\" minOccurs=\"1\" maxOccurs=\"unbounded\"/>\n", | |
| " </xs:sequence>\n", | |
| " </xs:complexType>\n", | |
| "\n", | |
| " <!-- Root element -->\n", | |
| " <xs:element name=\"function_calls\" type=\"FunctionCallsType\"/>\n", | |
| "\n", | |
| "</xs:schema>\n", | |
| "\"\"\"\n" | |
| ], | |
| "metadata": { | |
| "id": "vzYR_G3rOC95" | |
| }, | |
| "execution_count": 5, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Defining Tools for Function Calls\n", | |
| "\n", | |
| "With the provided titles, names, descriptions, and corresponding XML Schema types for each tool, you have created two structured tool descriptions designed for inclusion in a system prompt for Claude. These descriptions encapsulate the functionality and expected inputs for an Arithmetic Operation Tool and a Random String Generator, respectively. By formatting these descriptions according to the specified schema, you ensure that the tools are clearly defined and understandable within the context of interacting with Claude. The `tools` list now contains these formatted descriptions, ready to be integrated into a system prompt or documentation that instructs on how to utilize these tools within an AI-assisted environment." | |
| ], | |
| "metadata": { | |
| "id": "w2QfPChz3tqX" | |
| } | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "### Tool 1: Arithmetic Operation Tool" | |
| ], | |
| "metadata": { | |
| "id": "fQkPXhbXDlZg" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "# Create tools for the system prompt\n", | |
| "title = \"Arithmetic Operation Tool\"\n", | |
| "# This name must be defined in extract_and_evaluate_operations function\n", | |
| "name = \"do_pairwise_arithmetic\"\n", | |
| "description = \"Performs arithmetic operations that can be nested, each defined by an operator and consisting of operands that are either numbers or further operations.\"\n", | |
| "# OperationType refers to schema\n", | |
| "tool1 = construct_format_tool_for_claude_prompt(title, name, description, 'OperationType')" | |
| ], | |
| "metadata": { | |
| "id": "2beK8PkIyUxg" | |
| }, | |
| "execution_count": 6, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "### Tool 2: Random String Generator" | |
| ], | |
| "metadata": { | |
| "id": "HaugqhVFDqd1" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "title = \"Random String Generator\"\n", | |
| "# This name must be defined in extract_and_evaluate_operations function\n", | |
| "name = \"do_random_string\"\n", | |
| "description = \"Generates a random string of a specified length, providing a tool for creating unique identifiers, test data, or any scenario where random string generation is needed. The length of the string can be adjusted to range from 1 to 1024 characters.\"\n", | |
| "# RandomType refers to schema\n", | |
| "tool2 = construct_format_tool_for_claude_prompt(title, name, description, 'RandomType')" | |
| ], | |
| "metadata": { | |
| "id": "x8-_jFxVDq28" | |
| }, | |
| "execution_count": 7, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "### Add Tools" | |
| ], | |
| "metadata": { | |
| "id": "s5F50WfaD3Hc" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "# Add tools to the list\n", | |
| "tools = [tool1, tool2]" | |
| ], | |
| "metadata": { | |
| "id": "745AcfoND3cc" | |
| }, | |
| "execution_count": 8, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Final Results\n", | |
| "\n", | |
| "In this scenario, the `function_calling` function is designed to process the `user_prompt`, which requests the multiplication of two large numbers and the generation of a random string of 32 characters. The function utilizes the `tools` list, which contains descriptions of available tools (an Arithmetic Operation Tool and a Random String Generator), along with the `function_call_schema` for XML validation. Here's an outline of what happens within `function_calling`:\n", | |
| "\n", | |
| "1. **Construct System Prompt**: The function first constructs a comprehensive system prompt for Claude using the `tools` descriptions. This prompt outlines how to invoke the available tools and the parameters they accept, based on the schema.\n", | |
| "\n", | |
| "2. **Generate XML for Function Calls**: Claude is then prompted to generate XML representing the function calls specified by the `user_prompt`. This step involves Claude interpreting the user's request, translating it into structured XML that conforms to the `function_call_schema`.\n", | |
| "\n", | |
| "3. **Validate Generated XML**: The generated XML is validated against the `function_call_schema` to ensure it accurately represents the requested operations and adheres to the defined structure and data types.\n", | |
| "\n", | |
| "4. **Process Valid XML**: If the XML is valid, the `function_calling` function processes it to perform the specified arithmetic operation and random string generation. This involves evaluating the XML to compute the result of the multiplication and generate the requested random string.\n", | |
| "\n", | |
| "5. **Construct Final Message**: Finally, the function constructs a message summarizing the results of the processed operations, which might include the outcome of the multiplication and the generated random string, formatted for clear communication back to the user.\n", | |
| "\n", | |
| "This process demonstrates an advanced integration of natural language processing, XML manipulation, schema validation, and AI-driven interaction to dynamically respond to user prompts with precise computational operations and custom data generation." | |
| ], | |
| "metadata": { | |
| "id": "WpFMOhVA4Xr9" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "user_prompt = \"Multiply 1,984,135 by 9,343,116 and make a random string of 32 characters\"\n", | |
| "\n", | |
| "message = function_calling(client, user_prompt, tools, function_call_schema)\n", | |
| "\n", | |
| "print(message)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "cT8tIhXeI4Px", | |
| "outputId": "5d359791-7fdb-46e5-8bf9-db29325f53d4" | |
| }, | |
| "execution_count": 9, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "\n", | |
| "\n", | |
| "The first invoke calls the arithmetic operation tool to multiply 1,984,135 by 9,343,116, which gives the result 18538003464660.\n", | |
| "\n", | |
| "The second invoke calls the random string generator tool to generate a random string of length 32, which produces the string \"0wgTEIjJdnnq4C2D29rL5YrH2jSgAyIc\".\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "### Arithmetic Operation in Sequence" | |
| ], | |
| "metadata": { | |
| "id": "x1ykTdrK584H" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "user_prompt = \"Multiply 123 by 234 and divide by 2*3\"\n", | |
| "\n", | |
| "message = function_calling(client, user_prompt, tools, function_call_schema)\n", | |
| "\n", | |
| "print(message)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "THWu77jQTIPN", | |
| "outputId": "5b9c3e32-6719-47fe-cdd7-a8486476b4eb" | |
| }, | |
| "execution_count": 10, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "\n", | |
| "\n", | |
| "To break this down:\n", | |
| "1. Multiply 123 by 234 to get 28782\n", | |
| "2. Multiply 2 by 3 to get 6 \n", | |
| "3. Divide 28782 by 6 to get 4797\n", | |
| "\n", | |
| "So the final result of multiplying 123 by 234 and then dividing by 2*3 is 4797.\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "### Nested Calculation with XML Message Debug\n", | |
| "\n", | |
| "**Debugging Output Option**: Since debug_xmls is set to True, the function would print the system prompt constructed from the provided tools and the XML generated in response to the user_prompt. This output would give insight into how the system interprets and plans to execute the calculation." | |
| ], | |
| "metadata": { | |
| "id": "SEVRf6_Z5iri" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "# Let system decide the precedence order of aritchmetic operations\n", | |
| "#user_prompt = \"Calculate 3*1+2-1/2\"\n", | |
| "\n", | |
| "# Define the precedence order of aritchmetic operations\n", | |
| "user_prompt = \"Calculate (3*(1+2)-1)/2\"\n", | |
| "\n", | |
| "message = function_calling(client, user_prompt, tools, function_call_schema, True)\n", | |
| "\n", | |
| "print(message)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "IsqM-tEDTpsW", | |
| "outputId": "e666c3b2-a04b-4886-8542-b7b141fd1769" | |
| }, | |
| "execution_count": 11, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "\n", | |
| "\n", | |
| "System prompt: In this environment you have access to a set of tools you can use to answer the user's question.\n", | |
| "\n", | |
| "You may call them like this:\n", | |
| "<function_calls>\n", | |
| "<invoke>\n", | |
| "<tool_name>$TOOL_NAME</tool_name>\n", | |
| "$PARAMETERS\n", | |
| "</invoke>\n", | |
| "</function_calls>\n", | |
| "\n", | |
| "Here are the tools available:\n", | |
| "<tools>\n", | |
| "<tool_description>\n", | |
| "<tool_title>Arithmetic Operation Tool</tool_title>\n", | |
| "<tool_name>do_pairwise_arithmetic</tool_name>\n", | |
| "<description>\n", | |
| "Performs arithmetic operations that can be nested, each defined by an operator and consisting of operands that are either numbers or further operations.\n", | |
| "</description>\n", | |
| "<operation type=\"OperationType\"/>\n", | |
| "</tool_description>\n", | |
| "<tool_description>\n", | |
| "<tool_title>Random String Generator</tool_title>\n", | |
| "<tool_name>do_random_string</tool_name>\n", | |
| "<description>\n", | |
| "Generates a random string of a specified length, providing a tool for creating unique identifiers, test data, or any scenario where random string generation is needed. The length of the string can be adjusted to range from 1 to 1024 characters.\n", | |
| "</description>\n", | |
| "<operation type=\"RandomType\"/>\n", | |
| "</tool_description>\n", | |
| "</tools>\n", | |
| "\n", | |
| "<!-- Schemas -->\n", | |
| "\n", | |
| "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">\n", | |
| "\n", | |
| " <!-- Simple type for the operator attribute -->\n", | |
| " <xs:simpleType name=\"OperatorType\">\n", | |
| " <xs:restriction base=\"xs:string\">\n", | |
| " <xs:enumeration value=\"+\"/>\n", | |
| " <xs:enumeration value=\"-\"/>\n", | |
| " <xs:enumeration value=\"*\"/>\n", | |
| " <xs:enumeration value=\"/\"/>\n", | |
| " </xs:restriction>\n", | |
| " </xs:simpleType>\n", | |
| "\n", | |
| " <!-- Complex type for the number element to include both integers and floats -->\n", | |
| " <xs:complexType name=\"NumberType\">\n", | |
| " <xs:simpleContent>\n", | |
| " <xs:extension base=\"xs:decimal\"/>\n", | |
| " </xs:simpleContent>\n", | |
| " </xs:complexType>\n", | |
| "\n", | |
| " <!-- Recursive complex type for the operation element -->\n", | |
| " <xs:complexType name=\"OperationType\">\n", | |
| " <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">\n", | |
| " <xs:element name=\"number\" type=\"NumberType\"/>\n", | |
| " <xs:element name=\"operation\" type=\"OperationType\"/>\n", | |
| " </xs:choice>\n", | |
| " <xs:attribute name=\"operator\" type=\"OperatorType\" use=\"required\"/>\n", | |
| " </xs:complexType>\n", | |
| "\n", | |
| " <!-- Definition for RandomType -->\n", | |
| " <xs:complexType name=\"RandomType\">\n", | |
| " <xs:simpleContent>\n", | |
| " <xs:extension base=\"xs:string\">\n", | |
| " <xs:attribute name=\"length\" type=\"xs:integer\" use=\"optional\"/>\n", | |
| " </xs:extension>\n", | |
| " </xs:simpleContent>\n", | |
| " </xs:complexType>\n", | |
| "\n", | |
| " <!-- Add more types to here -->\n", | |
| "\n", | |
| " <!-- Complex type for the invoke element with optional operation and randomstring -->\n", | |
| " <xs:complexType name=\"InvokeType\">\n", | |
| " <xs:sequence>\n", | |
| " <xs:element name=\"tool_name\" type=\"xs:string\"/>\n", | |
| " <xs:element name=\"operation\" type=\"OperationType\" minOccurs=\"0\"/>\n", | |
| " <xs:element name=\"randomstring\" type=\"RandomType\" minOccurs=\"0\"/>\n", | |
| " <!-- Add more type references to here -->\n", | |
| " </xs:sequence>\n", | |
| " </xs:complexType>\n", | |
| "\n", | |
| " <!-- Complex type for the function_calls element -->\n", | |
| " <xs:complexType name=\"FunctionCallsType\">\n", | |
| " <xs:sequence>\n", | |
| " <xs:element name=\"invoke\" type=\"InvokeType\" minOccurs=\"1\" maxOccurs=\"unbounded\"/>\n", | |
| " </xs:sequence>\n", | |
| " </xs:complexType>\n", | |
| "\n", | |
| " <!-- Root element -->\n", | |
| " <xs:element name=\"function_calls\" type=\"FunctionCallsType\"/>\n", | |
| "\n", | |
| "</xs:schema>\n", | |
| "\n", | |
| "\n", | |
| "\n", | |
| "Assistant message: <function_calls>\n", | |
| "<invoke>\n", | |
| "<tool_name>do_pairwise_arithmetic</tool_name>\n", | |
| "<operation operator=\"/\">\n", | |
| " <operation operator=\"-\">\n", | |
| " <operation operator=\"*\">\n", | |
| " <number>3</number>\n", | |
| " <operation operator=\"+\">\n", | |
| " <number>1</number>\n", | |
| " <number>2</number>\n", | |
| " </operation>\n", | |
| " </operation>\n", | |
| " <number>1</number>\n", | |
| " </operation>\n", | |
| " <number>2</number>\n", | |
| "</operation>\n", | |
| "</invoke>\n", | |
| "</function_calls>\n", | |
| "<function_results>\n", | |
| "<result>\n", | |
| "<tool_name>do_pairwise_arithmetic</tool_name>\n", | |
| "<stdout>\n", | |
| "4.0\n", | |
| "</stdout>\n", | |
| "</result>\n", | |
| "</function_results>\n", | |
| "\n", | |
| "\n", | |
| "The calculation proceeds as follows:\n", | |
| "1. (1 + 2) = 3\n", | |
| "2. (3 * 3) = 9 \n", | |
| "3. (9 - 1) = 8\n", | |
| "4. (8 / 2) = 4.0\n", | |
| "\n", | |
| "So the result of the expression (3*(1+2)-1)/2 is 4.0.\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Conclusion\n", | |
| "\n", | |
| "In this Colab notebook, we've demonstrated a comprehensive approach to integrating and automating XML-based function calls within a Python environment, leveraging the Anthropic Claude model for processing natural language inputs into structured XML commands. The notebook includes a detailed XML Schema Definition (XSD) that outlines the structure for arithmetic operations and random string generation requests, ensuring precise and validated XML document generation that aligns with specified functionalities.\n", | |
| "\n", | |
| "Through a series of meticulously designed functions, the notebook showcases the process of parsing user prompts into XML format, validating these XML documents against the defined schema, and executing the described operations. This includes arithmetic calculations and the generation of secure random strings, embodying a flexible and dynamic system capable of handling complex user requests with accuracy and efficiency.\n", | |
| "\n", | |
| "Furthermore, the notebook illustrates the power of AI-driven automation in parsing and responding to natural language queries, translating them into executable actions that adhere to strict data type and structure requirements. By integrating tools like the Anthropic Claude model, the system not only enhances the precision of operations but also extends its applicability to a wide range of computational and data generation tasks." | |
| ], | |
| "metadata": { | |
| "id": "W06R7m-r8eTT" | |
| } | |
| } | |
| ] | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
👀 amazing.. share your prompt knowledge 🧠 with God Tier Prompts!