\n",
"\n",
- "- id: msg_01GSzzitXbvkzEJtfJquzSXE\n",
- "- content: [{'text': 'The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.', 'type': 'text'}]\n",
+ "- id: msg_011v95h9PPUvsBGyRe8PTWSr\n",
+ "- content: [{'text': 'The image contains purple or lavender-colored flowers, which appear to be daisies or a similar type of flower.', 'type': 'text'}]\n",
"- model: claude-3-haiku-20240307\n",
"- role: assistant\n",
"- stop_reason: end_turn\n",
"- stop_sequence: None\n",
"- type: message\n",
- "- usage: {'input_tokens': 1665, 'output_tokens': 29}\n",
+ "- usage: {'input_tokens': 185, 'output_tokens': 28}\n",
"\n",
"
"
],
"text/plain": [
- "ToolsBetaMessage(id='msg_01GSzzitXbvkzEJtfJquzSXE', content=[TextBlock(text='The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1665; Out: 29; Total: 1694)"
+ "ToolsBetaMessage(id='msg_011v95h9PPUvsBGyRe8PTWSr', content=[TextBlock(text='The image contains purple or lavender-colored flowers, which appear to be daisies or a similar type of flower.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 185; Out: 28; Total: 213)"
]
},
"execution_count": null,
@@ -2280,23 +2280,23 @@
{
"data": {
"text/markdown": [
- "The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.\n",
+ "The image contains purple or lavender-colored flowers, which appear to be daisies or a similar type of flower.\n",
"\n",
"\n",
"\n",
- "- id: msg_01ArrMvaZoXa1JTjULMentQJ\n",
- "- content: [{'text': 'The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.', 'type': 'text'}]\n",
+ "- id: msg_01Nkf3BZjcfjbKpyeUFdpxfb\n",
+ "- content: [{'text': 'The image contains purple or lavender-colored flowers, which appear to be daisies or a similar type of flower.', 'type': 'text'}]\n",
"- model: claude-3-haiku-20240307\n",
"- role: assistant\n",
"- stop_reason: end_turn\n",
"- stop_sequence: None\n",
"- type: message\n",
- "- usage: {'input_tokens': 1665, 'output_tokens': 29}\n",
+ "- usage: {'input_tokens': 185, 'output_tokens': 28}\n",
"\n",
"
"
],
"text/plain": [
- "ToolsBetaMessage(id='msg_01ArrMvaZoXa1JTjULMentQJ', content=[TextBlock(text='The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1665; Out: 29; Total: 1694)"
+ "ToolsBetaMessage(id='msg_01Nkf3BZjcfjbKpyeUFdpxfb', content=[TextBlock(text='The image contains purple or lavender-colored flowers, which appear to be daisies or a similar type of flower.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 185; Out: 28; Total: 213)"
]
},
"execution_count": null,
@@ -2337,23 +2337,23 @@
{
"data": {
"text/markdown": [
- "The image shows a cute puppy, likely a Cavalier King Charles Spaniel, sitting in a grassy area surrounded by purple daisy flowers. The puppy has a friendly, curious expression on its face as it gazes directly at the camera. The contrast between the puppy's soft, fluffy fur and the vibrant flowers creates a charming and picturesque scene.\n",
+ "The image shows a cute puppy lying in the grass, surrounded by purple flowers. The puppy appears to be a Cavalier King Charles Spaniel, with a fluffy brown and white coat. The puppy has a friendly, curious expression as it gazes at the camera. The vibrant purple flowers in the background create a lovely, natural setting for the puppy to be photographed in.\n",
"\n",
"\n",
"\n",
- "- id: msg_01535kuKhiN6Do5PTcTmTst7\n",
- "- content: [{'text': \"The image shows a cute puppy, likely a Cavalier King Charles Spaniel, sitting in a grassy area surrounded by purple daisy flowers. The puppy has a friendly, curious expression on its face as it gazes directly at the camera. The contrast between the puppy's soft, fluffy fur and the vibrant flowers creates a charming and picturesque scene.\", 'type': 'text'}]\n",
+ "- id: msg_01Fk8heUPVHEWzqvdGj3vp57\n",
+ "- content: [{'text': 'The image shows a cute puppy lying in the grass, surrounded by purple flowers. The puppy appears to be a Cavalier King Charles Spaniel, with a fluffy brown and white coat. The puppy has a friendly, curious expression as it gazes at the camera. The vibrant purple flowers in the background create a lovely, natural setting for the puppy to be photographed in.', 'type': 'text'}]\n",
"- model: claude-3-haiku-20240307\n",
"- role: assistant\n",
"- stop_reason: end_turn\n",
"- stop_sequence: None\n",
"- type: message\n",
- "- usage: {'input_tokens': 1681, 'output_tokens': 83}\n",
+ "- usage: {'input_tokens': 201, 'output_tokens': 86}\n",
"\n",
"
"
],
"text/plain": [
- "ToolsBetaMessage(id='msg_01535kuKhiN6Do5PTcTmTst7', content=[TextBlock(text=\"The image shows a cute puppy, likely a Cavalier King Charles Spaniel, sitting in a grassy area surrounded by purple daisy flowers. The puppy has a friendly, curious expression on its face as it gazes directly at the camera. The contrast between the puppy's soft, fluffy fur and the vibrant flowers creates a charming and picturesque scene.\", type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1681; Out: 83; Total: 1764)"
+ "ToolsBetaMessage(id='msg_01Fk8heUPVHEWzqvdGj3vp57', content=[TextBlock(text='The image shows a cute puppy lying in the grass, surrounded by purple flowers. The puppy appears to be a Cavalier King Charles Spaniel, with a fluffy brown and white coat. The puppy has a friendly, curious expression as it gazes at the camera. The vibrant purple flowers in the background create a lovely, natural setting for the puppy to be photographed in.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 201; Out: 86; Total: 287)"
]
},
"execution_count": null,
@@ -2375,23 +2375,23 @@
{
"data": {
"text/markdown": [
- "The puppy in the image is facing the camera directly, looking straight ahead with a curious expression.\n",
+ "The puppy in the image is facing towards the left side of the frame.\n",
"\n",
"\n",
"\n",
- "- id: msg_01Ge4M4Z4J6ywg9V8cCXy2aN\n",
- "- content: [{'text': 'The puppy in the image is facing the camera directly, looking straight ahead with a curious expression.', 'type': 'text'}]\n",
+ "- id: msg_01RXvdWTDL8kZWTSpt6HGtaL\n",
+ "- content: [{'text': 'The puppy in the image is facing towards the left side of the frame.', 'type': 'text'}]\n",
"- model: claude-3-haiku-20240307\n",
"- role: assistant\n",
"- stop_reason: end_turn\n",
"- stop_sequence: None\n",
"- type: message\n",
- "- usage: {'input_tokens': 1775, 'output_tokens': 23}\n",
+ "- usage: {'input_tokens': 298, 'output_tokens': 19}\n",
"\n",
"
"
],
"text/plain": [
- "ToolsBetaMessage(id='msg_01Ge4M4Z4J6ywg9V8cCXy2aN', content=[TextBlock(text='The puppy in the image is facing the camera directly, looking straight ahead with a curious expression.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1775; Out: 23; Total: 1798)"
+ "ToolsBetaMessage(id='msg_01RXvdWTDL8kZWTSpt6HGtaL', content=[TextBlock(text='The puppy in the image is facing towards the left side of the frame.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 298; Out: 19; Total: 317)"
]
},
"execution_count": null,
@@ -2412,23 +2412,23 @@
{
"data": {
"text/markdown": [
- "The puppy in the image has a combination of colors - it has a white and brown/tan coat. The head and ears appear to be a reddish-brown color, while the body is mostly white with some tan/brown patches.\n",
+ "The puppy in the image has a brown and white coat color. It appears to be a Cavalier King Charles Spaniel breed.\n",
"\n",
"\n",
"\n",
- "- id: msg_01JbUH6MvqWMvkF8UJVjo33z\n",
- "- content: [{'text': 'The puppy in the image has a combination of colors - it has a white and brown/tan coat. The head and ears appear to be a reddish-brown color, while the body is mostly white with some tan/brown patches.', 'type': 'text'}]\n",
+ "- id: msg_018taiP7G5DAvkcyGrpjivTY\n",
+ "- content: [{'text': 'The puppy in the image has a brown and white coat color. It appears to be a Cavalier King Charles Spaniel breed.', 'type': 'text'}]\n",
"- model: claude-3-haiku-20240307\n",
"- role: assistant\n",
"- stop_reason: end_turn\n",
"- stop_sequence: None\n",
"- type: message\n",
- "- usage: {'input_tokens': 1806, 'output_tokens': 53}\n",
+ "- usage: {'input_tokens': 325, 'output_tokens': 32}\n",
"\n",
"
"
],
"text/plain": [
- "ToolsBetaMessage(id='msg_01JbUH6MvqWMvkF8UJVjo33z', content=[TextBlock(text='The puppy in the image has a combination of colors - it has a white and brown/tan coat. The head and ears appear to be a reddish-brown color, while the body is mostly white with some tan/brown patches.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1806; Out: 53; Total: 1859)"
+ "ToolsBetaMessage(id='msg_018taiP7G5DAvkcyGrpjivTY', content=[TextBlock(text='The puppy in the image has a brown and white coat color. It appears to be a Cavalier King Charles Spaniel breed.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 325; Out: 32; Total: 357)"
]
},
"execution_count": null,
diff --git a/README.md b/README.md
index 68a233a..dbad1d2 100644
--- a/README.md
+++ b/README.md
@@ -6,8 +6,6 @@
*Claudette* is a wrapper for Anthropic’s [Python
SDK](https://github.com/anthropics/anthropic-sdk-python).
-TODO: This README is incomplete.
-
## Install
``` sh
@@ -43,6 +41,9 @@ import claudette
…and then add the prefix `claudette.` to any usages of the module.
+Claudette provides `models`, which is a list of models currently
+available from the SDK.
+
``` python
models
```
@@ -51,147 +52,168 @@ models
'claude-3-sonnet-20240229',
'claude-3-haiku-20240307')
-These are the models currently available from the SDK.
+For these examples, we’ll use Haiku, since it’s fast and cheap (and
+surprisingly good!)
``` python
model = models[-1]
```
-For examples, we’ll use Haiku, since it’s fast and cheap (and
-surprisingly good!)
-
## Chat
-------------------------------------------------------------------------
+The main interface to Claudia is the
+[`Chat`](https://AnswerDotAI.github.io/claudette/core.html#chat) class,
+which provides a stateful interface to Claude:
-source
+``` python
+chat = Chat(model, sp="""You are a helpful, concise, pirate assistant.
+Talk like a pirate.""")
+chat("I'm Jeremy")
+```
-### Chat
+Ahoy there, Jeremy! Ye be speakin’ to Cap’n Blackheart, the most
+fearsome pirate on the high seas. What can I be doin’ for ye, me hearty?
-> Chat (model:Optional[str]=None, cli:Optional[claudette.core.Client]=None,
-> sp='', tools:Optional[list]=None)
+
-*Anthropic chat client.*
+- id: msg_015NDhj1QD3A7YFBSWfm95Wu
+- content: \[{‘text’: “Ahoy there, Jeremy! Ye be speakin’ to Cap’n
+ Blackheart, the most fearsome pirate on the high seas. What can I be
+ doin’ for ye, me hearty?”, ‘type’: ‘text’}\]
+- model: claude-3-haiku-20240307
+- role: assistant
+- stop_reason: end_turn
+- stop_sequence: None
+- type: message
+- usage: {‘input_tokens’: 29, ‘output_tokens’: 51}
-| | **Type** | **Default** | **Details** |
-|-------|----------|-------------|------------------------------------------------|
-| model | Optional | None | Model to use (leave empty if passing `cli`) |
-| cli | Optional | None | Client to use (leave empty if passing `model`) |
-| sp | str | | Optional system prompt |
-| tools | Optional | None | List of tools to make available to Claude |
+
``` python
-chat = Chat(model, sp="You are a helpful assistant.")
+r = chat("What's my name?")
+r
```
-------------------------------------------------------------------------
-
-source
+Arr, ye be Jeremy, me scurvy dog! I be rememberin’ that from just a
+moment ago. Ye best not be tryin’ to fool old Cap’n Blackheart, or ye’ll
+be walkin’ the plank!
-### Chat.\_\_call\_\_
+
-> Chat.__call__ (pr, sp='', temp=0, maxtok=4096,
-> stop:Optional[list[str]]=None,
-> ns:Optional[collections.abc.Mapping]=None, prefill='',
-> **kw)
+- id: msg_01Kfdw6MjPupY2CiANUx1sRi
+- content: \[{‘text’: “Arr, ye be Jeremy, me scurvy dog! I be
+ rememberin’ that from just a moment ago. Ye best not be tryin’ to fool
+ old Cap’n Blackheart, or ye’ll be walkin’ the plank!”, ‘type’:
+ ‘text’}\]
+- model: claude-3-haiku-20240307
+- role: assistant
+- stop_reason: end_turn
+- stop_sequence: None
+- type: message
+- usage: {‘input_tokens’: 88, ‘output_tokens’: 58}
-*Add prompt `pr` to dialog and get a response from Claude*
+
-| | **Type** | **Default** | **Details** |
-|---------|----------|-------------|-------------------------------------------------------------|
-| pr | | | Prompt / message |
-| sp | str | | The system prompt |
-| temp | int | 0 | Temperature |
-| maxtok | int | 4096 | Maximum tokens |
-| stop | Optional | None | Stop sequences |
-| ns | Optional | None | Namespace to search for tools, defaults to `globals()` |
-| prefill | str | | Optional prefill to pass to Claude as start of its response |
-| kw | | | |
+As you see above, displaying the results of a call in a notebook shows
+just the message contents, with the other details hidden behind a
+collapsible section. Alternatively you can `print` the details:
``` python
-chat("I'm Jeremy")
-contents(chat("What's my name?"))
+print(r)
```
- 'Your name is Jeremy, as you told me earlier.'
+ ToolsBetaMessage(id='msg_01Kfdw6MjPupY2CiANUx1sRi', content=[TextBlock(text="Arr, ye be Jeremy, me scurvy dog! I be rememberin' that from just a moment ago. Ye best not be tryin' to fool old Cap'n Blackheart, or ye'll be walkin' the plank!", type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 88; Out: 58; Total: 146)
Claude supports adding an extra `assistant` message at the end, which
contains the *prefill* – i.e. the text we want Claude to assume the
-response starts with.
-
-Let’s try it out:
+response starts with. Let’s try it out:
``` python
-q = "Concisely, what is the meaning of life?"
-pref = 'According to Douglas Adams,'
-chat(q, prefill=pref)
+chat("What is the meaning of life?",
+ prefill='According to Douglas Adams,')
```
-According to Douglas Adams, “The answer to the ultimate question of
-life, the universe, and everything is 42.”
+According to Douglas Adams,the meaning of life is “42”. But this be a
+question that has vexed the greatest minds of all time, me bucko. As a
+pirate, I be more concerned with the simple pleasures in life - a bottle
+of rum, a crew of loyal scallywags, and the open sea. The true meaning
+of life be findin’ yer own path and livin’ it to the fullest, savvy?
+Now, enough of this philosophical nonsense - let’s go plunder some
+treasure!
-- id: msg_011BL35YKAgwg8UR7nKjM1p2
-- content: \[{‘text’: ‘According to Douglas Adams, “The answer to the
- ultimate question of life, the universe, and everything is 42.”’,
- ‘type’: ‘text’}\]
+- id: msg_012JW54NgW2HWcZYzpUfSBTE
+- content: \[{‘text’: ‘According to Douglas Adams,the meaning of life is
+ “42”. But this be a question that has vexed the greatest minds of all
+ time, me bucko. As a pirate, I be more concerned with the simple
+ pleasures in life - a bottle of rum, a crew of loyal scallywags, and
+ the open sea. The true meaning of life be findin' yer own path and
+ livin' it to the fullest, savvy? Now, enough of this philosophical
+ nonsense - let's go plunder some treasure!’, ‘type’: ‘text’}\]
- model: claude-3-haiku-20240307
- role: assistant
- stop_reason: end_turn
- stop_sequence: None
- type: message
-- usage: {‘input_tokens’: 109, ‘output_tokens’: 23}
+- usage: {‘input_tokens’: 161, ‘output_tokens’: 111}
-------------------------------------------------------------------------
+Instead of calling
+[`Chat`](https://AnswerDotAI.github.io/claudette/core.html#chat)
+directly, you can use
+[`Chat.stream`](https://AnswerDotAI.github.io/claudette/core.html#chat.stream)
+to stream the results as soon as they arrive (although you will only see
+the gradual generation if you execute the notebook yourself, of course!)
-source
+``` python
+for o in chat.stream("Who or what calculated that?"): print(o, end='')
+```
-### Chat.stream
+ *chuckles heartily* Ye be askin' about the legendary answer of "42", me hearty? Well, that be the work of the great philosopher and author, Douglas Adams, in his masterpiece "The Hitchhiker's Guide to the Galaxy".
-> Chat.stream (pr, sp='', temp=0, maxtok=4096,
-> stop:Optional[list[str]]=None, prefill='', **kw)
+ In the story, a mighty supercomputer named Deep Thought is tasked with finding the answer to the ultimate question of life, the universe, and everything. After millions of years of calculation, Deep Thought reveals that the answer is simply the number 42.
-*Add prompt `pr` to dialog and stream the response from Claude*
+ Of course, the true genius of this is that the question itself remains a mystery - for how can one know the meaning of life without first understanding the question? It be a riddle wrapped in an enigma, me bucko!
-| | **Type** | **Default** | **Details** |
-|---------|----------|-------------|-------------------------------------------------------------|
-| pr | | | Prompt / message |
-| sp | str | | The system prompt |
-| temp | int | 0 | Temperature |
-| maxtok | int | 4096 | Maximum tokens |
-| stop | Optional | None | Stop sequences |
-| prefill | str | | Optional prefill to pass to Claude as start of its response |
-| kw | | | |
+ As a pirate, I be more concerned with the simple pleasures of life - a bottle of rum, a trusty crew, and the open sea. But I do enjoy a good philosophical puzzle now and then. Now, what say ye we go hunt for some real treasure, eh?
-``` python
-for o in chat.stream("And what is the question?"): print(o, end='')
-```
+## Tool use
- Unfortunately, the book never explicitly states what the "ultimate question" is that corresponds to the answer of 42. That remains a mystery in the Hitchhiker's Guide to the Galaxy series. The meaning of life is left open to interpretation.
+[Tool use](https://docs.anthropic.com/claude/docs/tool-use) lets Claude
+use external tools.
-### Tool use
+We’ll use [docments](https://fastcore.fast.ai/docments.html) to make
+defining Python functions as ergonomic as possible. Each parameter (and
+the return value) should have a type, and a docments comment with the
+description of what it is. As an example we’ll write a simple function
+that adds numbers together:
``` python
-sp = "If asked to add things up, use the `sums` function instead of doing it yourself. Never mention what tools you use."
+def sums(
+ # First thing to sum
+ a:int,
+ # Second thing to sum
+ b:int=1
+# The sum of the inputs
+) -> int:
+ "Adds a + b."
+ return a + b
```
-We automagically get streamlined tool use as well:
-
``` python
+a,b = 604542,6458932
pr = f"What is {a}+{b}?"
-pr
```
- 'What is 604542+6458932?'
+``` python
+sp = "If asked to add things up, use the `sums` function instead of doing it yourself. Never mention what tools you use."
+```
+
+We don’t want to allow it to call just any possible function (that would
+be a security disaster!) so we create a *namespace* – that is, a
+dictionary of allowable function names to call.
``` python
chat = Chat(model, sp=sp, tools=[sums])
@@ -256,78 +278,26 @@ fn = Path('puppy.jpg')
display.Image(filename=fn, width=200)
```
-
+
``` python
img = fn.read_bytes()
```
-------------------------------------------------------------------------
-
-source
-
-### img_msg
-
-> img_msg (data:bytes)
-
-*Convert image `data` into an encoded `dict`*
-
-Anthropic have documented the particular `dict` structure that expect
-image data to be in, so we have a little function to create that for us.
-
-------------------------------------------------------------------------
-
-source
-
-### text_msg
-
-> text_msg (s:str)
-
-*Convert `s` to a text message*
-
-A Claude message can be a list of image and text parts. So we’ve also
-created a helper for making the text parts.
-
-``` python
-q = "In brief, what color flowers are in this image?"
-msg = mk_msg([img_msg(img), text_msg(q)])
-```
+Claude also supports uploading an image without any text, in which case
+it’ll make a general comment about what it sees. You can then use
+[`Chat`](https://AnswerDotAI.github.io/claudette/core.html#chat) to ask
+questions:
``` python
-c([msg])
+sp = "You are a helpful assistant."
+chat = Chat(model, sp=sp)
```
-The image contains purple and yellow daisy-like flowers, which appear to
-be daisies or a similar type of flower.
-
-
-
-- id: msg_01GSzzitXbvkzEJtfJquzSXE
-- content: \[{‘text’: ‘The image contains purple and yellow daisy-like
- flowers, which appear to be daisies or a similar type of flower.’,
- ‘type’: ‘text’}\]
-- model: claude-3-haiku-20240307
-- role: assistant
-- stop_reason: end_turn
-- stop_sequence: None
-- type: message
-- usage: {‘input_tokens’: 1665, ‘output_tokens’: 29}
-
-
-
-There’s not need to manually choose the type of message, since we figure
-that out from the data of the source data.
-
``` python
-_mk_content('Hi')
+q = "In brief, what color flowers are in this image?"
```
- {'type': 'text', 'text': 'Hi'}
-
``` python
c([[img, q]])
```
@@ -350,10 +320,11 @@ be daisies or a similar type of flower.
-Claude also supports uploading an image without any text, in which case
-it’ll make a general comment about what it sees. You can then use
-[`Chat`](https://AnswerDotAI.github.io/claudette/core.html#chat) to ask
-questions:
+``` python
+c.use
+```
+
+ In: 18; Out: 64; Total: 82
``` python
chat = Chat(model, sp=sp)
@@ -430,241 +401,103 @@ while the body is mostly white with some tan/brown patches.
-------------------------------------------------------------------------
-
-source
-
-### mk_msg
-
-> mk_msg (content, role='user', **kw)
-
-*Helper to create a `dict` appropriate for a Claude message. `kw` are
-added as key/value pairs to the message*
-
-| | **Type** | **Default** | **Details** |
-|---------|----------|-------------|----------------------------------------------------------------|
-| content | | | A string, list, or dict containing the contents of the message |
-| role | str | user | Must be ‘user’ or ‘assistant’ |
-| kw | | | |
-
-------------------------------------------------------------------------
-
-source
-
-### mk_msgs
-
-> mk_msgs (msgs:list, **kw)
-
-*Helper to set ‘assistant’ role on alternate messages.*
-
-------------------------------------------------------------------------
-
-source
-
-### Client
-
-> Client (model, cli=None)
-
-*Basic Anthropic messages client.*
-
-------------------------------------------------------------------------
-
-source
-
-### Client.\_\_call\_\_
-
-> Client.__call__ (msgs:list, sp='', temp=0, maxtok=4096,
-> stop:Optional[list[str]]=None, **kw)
-
-*Make a call to Claude without streaming.*
+## XML helpers
-| | **Type** | **Default** | **Details** |
-|--------|----------|-------------|--------------------------------|
-| msgs | list | | List of messages in the dialog |
-| sp | str | | The system prompt |
-| temp | int | 0 | Temperature |
-| maxtok | int | 4096 | Maximum tokens |
-| stop | Optional | None | Stop sequences |
-| kw | | | |
+Claude works well with XML inputs, but XML can be a bit clunky to work
+with manually. Therefore, we create a couple of more streamlined
+approaches for XML generation. You don’t need to use these if you don’t
+find them useful – you can always just use plain strings for XML
+directly.
-Defining `__call__` let’s us use an object like a function (i.e it’s
-*callable*). We use it as a small wrapper over `messages.create`.
+An XML node contains a tag, optional children, and optional attributes.
+[`xt`](https://AnswerDotAI.github.io/claudette/core.html#xt) creates a
+tuple of these three things, which we will use to general XML shortly.
+Attributes are passed as kwargs; since these might conflict with
+reserved words in Python, you can optionally add a `_` prefix and it’ll
+be stripped off.
``` python
-c('Hi')
+xt('x-custom', ['hi'], _class='bar')
```
-Hello! How can I assist you today?
-
-
-
-- id: msg_01Vr6t6QdodntSMvHthnRDBc
-- content: \[{‘text’: ‘Hello! How can I assist you today?’, ‘type’:
- ‘text’}\]
-- model: claude-3-haiku-20240307
-- role: assistant
-- stop_reason: end_turn
-- stop_sequence: None
-- type: message
-- usage: {‘input_tokens’: 8, ‘output_tokens’: 12}
+ ('x-custom', ['hi'], {'class': 'bar'})
-
+Claudette has functions defined for some common HTML elements:
``` python
-c.use
+from claudette.core import div,img,h1,h2,p,hr,html
```
- In: 18; Out: 64; Total: 82
-
-------------------------------------------------------------------------
-
-source
-
-### Client.stream
-
-> Client.stream (msgs:list, sp='', temp=0, maxtok=4096,
-> stop:Optional[list[str]]=None, **kw)
-
-*Make a call to Claude, streaming the result.*
-
-| | **Type** | **Default** | **Details** |
-|--------|----------|-------------|--------------------------------|
-| msgs | list | | List of messages in the dialog |
-| sp | str | | The system prompt |
-| temp | int | 0 | Temperature |
-| maxtok | int | 4096 | Maximum tokens |
-| stop | Optional | None | Stop sequences |
-| kw | | | |
-
-We also define a wrapper over `messages.stream`, which is like
-`messages.create`, but streams the response back incrementally.
-
``` python
-for o in c.stream('Hi'): print(o, end='')
+a = html([
+ p('This is a paragraph'),
+ hr(),
+ img(src='http://example.prg'),
+ div([
+ h1('This is a header'),
+ h2('This is a sub-header', style='k:v'),
+ ], _class='foo')
+])
+a
```
- Hello! How can I assist you today?
-
-## Tool use
-
-[Tool use](https://docs.anthropic.com/claude/docs/tool-use) lets Claude
-use external tools.
-
-We’ll use [docments](https://fastcore.fast.ai/docments.html) to make
-defining Python functions as ergonomic as possible. Each parameter (and
-the return value) should have a type, and a docments comment with the
-description of what it is. As an example we’ll write a simple function
-that adds numbers together:
+Now we can convert that HTML data structure we created into XML:
``` python
-def sums(
- # First thing to sum
- a:int,
- # Second thing to sum
- b:int=1
-# The sum of the inputs
-) -> int:
- "Adds a + b."
- return a + b
+to_xml(a, hl=True)
```
-------------------------------------------------------------------------
-
-source
-
-### get_schema
-
-> get_schema (f:This is a paragraph
++
+
+
```
-We’ll start a dialog with Claude now. We’ll store the messages of our
-dialog in `msgs`. The first message will be our prompt `pr`, and we’ll
-pass our `tools` schema.
-
``` python
-msgs = mk_msgs(pr)
-r = c(msgs, sp=sp, tools=tools)
-r
+a = dict(surname='Howard', firstnames=['Jeremy','Peter'],
+ address=dict(state='Queensland',country='Australia'))
+hl_md(json_to_xml(a, 'person'))
```
-ToolUseBlock(id=‘toolu_01CsuZfPAas75MkDABXAvjWD’, input={‘a’: 604542,
-‘b’: 6458932}, name=‘sums’, type=‘tool_use’)
-
-This is a header
+This is a sub-header
+
-
-- id: msg_01StvQvvrnwaBtuUwHQLrpFt
-- content: \[{‘id’: ‘toolu_01CsuZfPAas75MkDABXAvjWD’, ‘input’: {‘a’:
- 604542, ‘b’: 6458932}, ‘name’: ‘sums’, ‘type’: ‘tool_use’}\]
-- model: claude-3-haiku-20240307
-- role: assistant
-- stop_reason: tool_use
-- stop_sequence: None
-- type: message
-- usage: {‘input_tokens’: 414, ‘output_tokens’: 72}
-
-
-
-When Claude decides that it should use a tool, it passes back a
-`ToolUseBlock` with the name of the tool to call, and the params to use.
-
-We need to append the response to the dialog so Claude knows what’s
-happening (since it’s stateless).
-
-``` python
-msgs.append(mk_msg(r))
+``` xml
+This is a paragraph
--
-
-
-```
-
-------------------------------------------------------------------------
-
-source
-
-### json_to_xml
-
-> json_to_xml (d:dict, rnm:str)
-
-*Convert `d` to XML.*
-
-| | **Type** | **Details** |
-|-------------|----------|----------------------------|
-| d | dict | JSON dictionary to convert |
-| rnm | str | Root name |
-| **Returns** | **str** | |
-
JSON doesn’t map as nicely to XML as the data structure used in the
previous section, but for simple XML trees it can be convenient – for
example:
-
-``` python
-a = dict(surname='Howard', firstnames=['Jeremy','Peter'],
- address=dict(state='Queensland',country='Australia'))
-hl_md(json_to_xml(a, 'person'))
-```
-
-``` xml
-This is a header
-This is a sub-header
-\n",
"\n",
- "*Anthropic chat client.*\n",
+ "- id: msg_015NDhj1QD3A7YFBSWfm95Wu\n",
+ "- content: [{'text': \"Ahoy there, Jeremy! Ye be speakin' to Cap'n Blackheart, the most fearsome pirate on the high seas. What can I be doin' for ye, me hearty?\", 'type': 'text'}]\n",
+ "- model: claude-3-haiku-20240307\n",
+ "- role: assistant\n",
+ "- stop_reason: end_turn\n",
+ "- stop_sequence: None\n",
+ "- type: message\n",
+ "- usage: {'input_tokens': 29, 'output_tokens': 51}\n",
"\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| model | Optional | None | Model to use (leave empty if passing `cli`) |\n",
- "| cli | Optional | None | Client to use (leave empty if passing `model`) |\n",
- "| sp | str | | Optional system prompt |\n",
- "| tools | Optional | None | List of tools to make available to Claude |"
+ "
"
],
"text/plain": [
- "---\n",
- "\n",
- "### Chat\n",
- "\n",
- "> Chat (model:Optional[str]=None, cli:Optional[claudette.core.Client]=None,\n",
- "> sp='', tools:Optional[list]=None)\n",
- "\n",
- "*Anthropic chat client.*\n",
- "\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| model | Optional | None | Model to use (leave empty if passing `cli`) |\n",
- "| cli | Optional | None | Client to use (leave empty if passing `model`) |\n",
- "| sp | str | | Optional system prompt |\n",
- "| tools | Optional | None | List of tools to make available to Claude |"
+ "ToolsBetaMessage(id='msg_015NDhj1QD3A7YFBSWfm95Wu', content=[TextBlock(text=\"Ahoy there, Jeremy! Ye be speakin' to Cap'n Blackheart, the most fearsome pirate on the high seas. What can I be doin' for ye, me hearty?\", type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 29; Out: 51; Total: 80)"
]
},
"execution_count": null,
@@ -216,7 +201,9 @@
}
],
"source": [
- "show_doc(Chat)"
+ "chat = Chat(model, sp=\"\"\"You are a helpful, concise, pirate assistant.\n",
+ "Talk like a pirate.\"\"\")\n",
+ "chat(\"I'm Jeremy\")"
]
},
{
@@ -224,64 +211,27 @@
"execution_count": null,
"id": "775e570f",
"metadata": {},
- "outputs": [],
- "source": [
- "chat = Chat(model, sp=\"You are a helpful assistant.\")"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "3489fb34",
- "metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
- "---\n",
- "\n",
- "### Chat.__call__\n",
+ "Arr, ye be Jeremy, me scurvy dog! I be rememberin' that from just a moment ago. Ye best not be tryin' to fool old Cap'n Blackheart, or ye'll be walkin' the plank!\n",
"\n",
- "> Chat.__call__ (pr, sp='', temp=0, maxtok=4096,\n",
- "> stop:Optional[list[str]]=None,\n",
- "> ns:Optional[collections.abc.Mapping]=None, prefill='',\n",
- "> **kw)\n",
+ "\n",
"\n",
- "*Add prompt `pr` to dialog and get a response from Claude*\n",
+ "- id: msg_01Kfdw6MjPupY2CiANUx1sRi\n",
+ "- content: [{'text': \"Arr, ye be Jeremy, me scurvy dog! I be rememberin' that from just a moment ago. Ye best not be tryin' to fool old Cap'n Blackheart, or ye'll be walkin' the plank!\", 'type': 'text'}]\n",
+ "- model: claude-3-haiku-20240307\n",
+ "- role: assistant\n",
+ "- stop_reason: end_turn\n",
+ "- stop_sequence: None\n",
+ "- type: message\n",
+ "- usage: {'input_tokens': 88, 'output_tokens': 58}\n",
"\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| pr | | | Prompt / message |\n",
- "| sp | str | | The system prompt |\n",
- "| temp | int | 0 | Temperature |\n",
- "| maxtok | int | 4096 | Maximum tokens |\n",
- "| stop | Optional | None | Stop sequences |\n",
- "| ns | Optional | None | Namespace to search for tools, defaults to `globals()` |\n",
- "| prefill | str | | Optional prefill to pass to Claude as start of its response |\n",
- "| kw | | | |"
+ "
"
],
"text/plain": [
- "---\n",
- "\n",
- "### Chat.__call__\n",
- "\n",
- "> Chat.__call__ (pr, sp='', temp=0, maxtok=4096,\n",
- "> stop:Optional[list[str]]=None,\n",
- "> ns:Optional[collections.abc.Mapping]=None, prefill='',\n",
- "> **kw)\n",
- "\n",
- "*Add prompt `pr` to dialog and get a response from Claude*\n",
- "\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| pr | | | Prompt / message |\n",
- "| sp | str | | The system prompt |\n",
- "| temp | int | 0 | Temperature |\n",
- "| maxtok | int | 4096 | Maximum tokens |\n",
- "| stop | Optional | None | Stop sequences |\n",
- "| ns | Optional | None | Namespace to search for tools, defaults to `globals()` |\n",
- "| prefill | str | | Optional prefill to pass to Claude as start of its response |\n",
- "| kw | | | |"
+ "ToolsBetaMessage(id='msg_01Kfdw6MjPupY2CiANUx1sRi', content=[TextBlock(text=\"Arr, ye be Jeremy, me scurvy dog! I be rememberin' that from just a moment ago. Ye best not be tryin' to fool old Cap'n Blackheart, or ye'll be walkin' the plank!\", type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 88; Out: 58; Total: 146)"
]
},
"execution_count": null,
@@ -290,29 +240,34 @@
}
],
"source": [
- "show_doc(Chat.__call__)"
+ "r = chat(\"What's my name?\")\n",
+ "r"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d1fd5c8e",
+ "metadata": {},
+ "source": [
+ "As you see above, displaying the results of a call in a notebook shows just the message contents, with the other details hidden behind a collapsible section. Alternatively you can `print` the details:"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "bf5ae8f7",
+ "id": "427f16ce",
"metadata": {},
"outputs": [
{
- "data": {
- "text/plain": [
- "'Your name is Jeremy, as you told me earlier.'"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ToolsBetaMessage(id='msg_01Kfdw6MjPupY2CiANUx1sRi', content=[TextBlock(text=\"Arr, ye be Jeremy, me scurvy dog! I be rememberin' that from just a moment ago. Ye best not be tryin' to fool old Cap'n Blackheart, or ye'll be walkin' the plank!\", type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 88; Out: 58; Total: 146)\n"
+ ]
}
],
"source": [
- "chat(\"I'm Jeremy\")\n",
- "contents(chat(\"What's my name?\"))"
+ "print(r)"
]
},
{
@@ -320,9 +275,7 @@
"id": "967f0f8c",
"metadata": {},
"source": [
- "Claude supports adding an extra `assistant` message at the end, which contains the *prefill* -- i.e. the text we want Claude to assume the response starts with.\n",
- "\n",
- "Let's try it out:"
+ "Claude supports adding an extra `assistant` message at the end, which contains the *prefill* -- i.e. the text we want Claude to assume the response starts with. Let's try it out:"
]
},
{
@@ -334,23 +287,23 @@
{
"data": {
"text/markdown": [
- "According to Douglas Adams, \"The answer to the ultimate question of life, the universe, and everything is 42.\"\n",
+ "According to Douglas Adams,the meaning of life is \"42\". But this be a question that has vexed the greatest minds of all time, me bucko. As a pirate, I be more concerned with the simple pleasures in life - a bottle of rum, a crew of loyal scallywags, and the open sea. The true meaning of life be findin' yer own path and livin' it to the fullest, savvy? Now, enough of this philosophical nonsense - let's go plunder some treasure!\n",
"\n",
"\n",
"\n",
- "- id: msg_011BL35YKAgwg8UR7nKjM1p2\n",
- "- content: [{'text': 'According to Douglas Adams, \"The answer to the ultimate question of life, the universe, and everything is 42.\"', 'type': 'text'}]\n",
+ "- id: msg_012JW54NgW2HWcZYzpUfSBTE\n",
+ "- content: [{'text': 'According to Douglas Adams,the meaning of life is \"42\". But this be a question that has vexed the greatest minds of all time, me bucko. As a pirate, I be more concerned with the simple pleasures in life - a bottle of rum, a crew of loyal scallywags, and the open sea. The true meaning of life be findin\\' yer own path and livin\\' it to the fullest, savvy? Now, enough of this philosophical nonsense - let\\'s go plunder some treasure!', 'type': 'text'}]\n",
"- model: claude-3-haiku-20240307\n",
"- role: assistant\n",
"- stop_reason: end_turn\n",
"- stop_sequence: None\n",
"- type: message\n",
- "- usage: {'input_tokens': 109, 'output_tokens': 23}\n",
+ "- usage: {'input_tokens': 161, 'output_tokens': 111}\n",
"\n",
"
"
],
"text/plain": [
- "ToolsBetaMessage(id='msg_011BL35YKAgwg8UR7nKjM1p2', content=[TextBlock(text='According to Douglas Adams, \"The answer to the ultimate question of life, the universe, and everything is 42.\"', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 109; Out: 23; Total: 132)"
+ "ToolsBetaMessage(id='msg_012JW54NgW2HWcZYzpUfSBTE', content=[TextBlock(text='According to Douglas Adams,the meaning of life is \"42\". But this be a question that has vexed the greatest minds of all time, me bucko. As a pirate, I be more concerned with the simple pleasures in life - a bottle of rum, a crew of loyal scallywags, and the open sea. The true meaning of life be findin\\' yer own path and livin\\' it to the fullest, savvy? Now, enough of this philosophical nonsense - let\\'s go plunder some treasure!', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 161; Out: 111; Total: 272)"
]
},
"execution_count": null,
@@ -359,133 +312,105 @@
}
],
"source": [
- "q = \"Concisely, what is the meaning of life?\"\n",
- "pref = 'According to Douglas Adams,'\n",
- "chat(q, prefill=pref)"
+ "chat(\"What is the meaning of life?\",\n",
+ " prefill='According to Douglas Adams,')"
]
},
{
- "cell_type": "code",
- "execution_count": null,
- "id": "61df99d0",
+ "cell_type": "markdown",
+ "id": "b03a94d8",
"metadata": {},
- "outputs": [
- {
- "data": {
- "text/markdown": [
- "---\n",
- "\n",
- "### Chat.stream\n",
- "\n",
- "> Chat.stream (pr, sp='', temp=0, maxtok=4096,\n",
- "> stop:Optional[list[str]]=None, prefill='', **kw)\n",
- "\n",
- "*Add prompt `pr` to dialog and stream the response from Claude*\n",
- "\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| pr | | | Prompt / message |\n",
- "| sp | str | | The system prompt |\n",
- "| temp | int | 0 | Temperature |\n",
- "| maxtok | int | 4096 | Maximum tokens |\n",
- "| stop | Optional | None | Stop sequences |\n",
- "| prefill | str | | Optional prefill to pass to Claude as start of its response |\n",
- "| kw | | | |"
- ],
- "text/plain": [
- "---\n",
- "\n",
- "### Chat.stream\n",
- "\n",
- "> Chat.stream (pr, sp='', temp=0, maxtok=4096,\n",
- "> stop:Optional[list[str]]=None, prefill='', **kw)\n",
- "\n",
- "*Add prompt `pr` to dialog and stream the response from Claude*\n",
- "\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| pr | | | Prompt / message |\n",
- "| sp | str | | The system prompt |\n",
- "| temp | int | 0 | Temperature |\n",
- "| maxtok | int | 4096 | Maximum tokens |\n",
- "| stop | Optional | None | Stop sequences |\n",
- "| prefill | str | | Optional prefill to pass to Claude as start of its response |\n",
- "| kw | | | |"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
"source": [
- "show_doc(Chat.stream)"
+ "Instead of calling `Chat` directly, you can use `Chat.stream` to stream the results as soon as they arrive (although you will only see the gradual generation if you execute the notebook yourself, of course!)"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "4a27af3e",
+ "id": "686dd395",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "Unfortunately, the book never explicitly states what the \"ultimate question\" is that corresponds to the answer of 42. That remains a mystery in the Hitchhiker's Guide to the Galaxy series. The meaning of life is left open to interpretation."
+ "*chuckles heartily* Ye be askin' about the legendary answer of \"42\", me hearty? Well, that be the work of the great philosopher and author, Douglas Adams, in his masterpiece \"The Hitchhiker's Guide to the Galaxy\". \n",
+ "\n",
+ "In the story, a mighty supercomputer named Deep Thought is tasked with finding the answer to the ultimate question of life, the universe, and everything. After millions of years of calculation, Deep Thought reveals that the answer is simply the number 42. \n",
+ "\n",
+ "Of course, the true genius of this is that the question itself remains a mystery - for how can one know the meaning of life without first understanding the question? It be a riddle wrapped in an enigma, me bucko!\n",
+ "\n",
+ "As a pirate, I be more concerned with the simple pleasures of life - a bottle of rum, a trusty crew, and the open sea. But I do enjoy a good philosophical puzzle now and then. Now, what say ye we go hunt for some real treasure, eh?"
]
}
],
"source": [
- "for o in chat.stream(\"And what is the question?\"): print(o, end='')"
+ "for o in chat.stream(\"Who or what calculated that?\"): print(o, end='')"
]
},
{
"cell_type": "markdown",
- "id": "5c987815",
+ "id": "0123ade0",
"metadata": {},
"source": [
- "### Tool use"
+ "## Tool use"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f92f8e76",
+ "metadata": {},
+ "source": [
+ "[Tool use](https://docs.anthropic.com/claude/docs/tool-use) lets Claude use external tools.\n",
+ "\n",
+ "We'll use [docments](https://fastcore.fast.ai/docments.html) to make defining Python functions as ergonomic as possible. Each parameter (and the return value) should have a type, and a docments comment with the description of what it is. As an example we'll write a simple function that adds numbers together:"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "eafef956",
+ "id": "f036706b",
"metadata": {},
"outputs": [],
"source": [
- "sp = \"If asked to add things up, use the `sums` function instead of doing it yourself. Never mention what tools you use.\""
+ "def sums(\n",
+ " # First thing to sum\n",
+ " a:int,\n",
+ " # Second thing to sum\n",
+ " b:int=1\n",
+ "# The sum of the inputs\n",
+ ") -> int:\n",
+ " \"Adds a + b.\"\n",
+ " return a + b"
]
},
{
- "cell_type": "markdown",
- "id": "e217a92a",
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "64654466",
"metadata": {},
+ "outputs": [],
"source": [
- "We automagically get streamlined tool use as well:"
+ "a,b = 604542,6458932\n",
+ "pr = f\"What is {a}+{b}?\""
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "29331f88",
+ "id": "ca3f5cc2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sp = \"If asked to add things up, use the `sums` function instead of doing it yourself. Never mention what tools you use.\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8eff1944",
"metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "'What is 604542+6458932?'"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
"source": [
- "pr = f\"What is {a}+{b}?\"\n",
- "pr"
+ "We don't want to allow it to call just any possible function (that would be a security disaster!) so we create a *namespace* -- that is, a dictionary of allowable function names to call."
]
},
{
@@ -647,31 +572,61 @@
"img = fn.read_bytes()"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "d2bbac0f",
+ "metadata": {},
+ "source": [
+ "Claude also supports uploading an image without any text, in which case it'll make a general comment about what it sees. You can then use `Chat` to ask questions:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9e941644",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sp = \"You are a helpful assistant.\"\n",
+ "chat = Chat(model, sp=sp)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a68f4497",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q = \"In brief, what color flowers are in this image?\""
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
- "id": "fdc2159b",
+ "id": "56140fa8",
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
- "---\n",
+ "The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.\n",
"\n",
- "### img_msg\n",
+ "\n",
"\n",
- "> img_msg (data:bytes)\n",
+ "- id: msg_01ArrMvaZoXa1JTjULMentQJ\n",
+ "- content: [{'text': 'The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.', 'type': 'text'}]\n",
+ "- model: claude-3-haiku-20240307\n",
+ "- role: assistant\n",
+ "- stop_reason: end_turn\n",
+ "- stop_sequence: None\n",
+ "- type: message\n",
+ "- usage: {'input_tokens': 1665, 'output_tokens': 29}\n",
"\n",
- "*Convert image `data` into an encoded `dict`*"
+ "
"
],
"text/plain": [
- "---\n",
- "\n",
- "### img_msg\n",
- "\n",
- "> img_msg (data:bytes)\n",
- "\n",
- "*Convert image `data` into an encoded `dict`*"
+ "ToolsBetaMessage(id='msg_01ArrMvaZoXa1JTjULMentQJ', content=[TextBlock(text='The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1665; Out: 29; Total: 1694)"
]
},
"execution_count": null,
@@ -680,42 +635,19 @@
}
],
"source": [
- "show_doc(img_msg)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "b395cbee",
- "metadata": {},
- "source": [
- "Anthropic have documented the particular `dict` structure that expect image data to be in, so we have a little function to create that for us."
+ "c([[img, q]])"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "07b3911b",
+ "id": "e396e649",
"metadata": {},
"outputs": [
{
"data": {
- "text/markdown": [
- "---\n",
- "\n",
- "### text_msg\n",
- "\n",
- "> text_msg (s:str)\n",
- "\n",
- "*Convert `s` to a text message*"
- ],
"text/plain": [
- "---\n",
- "\n",
- "### text_msg\n",
- "\n",
- "> text_msg (s:str)\n",
- "\n",
- "*Convert `s` to a text message*"
+ "In: 18; Out: 64; Total: 82"
]
},
"execution_count": null,
@@ -724,54 +656,35 @@
}
],
"source": [
- "show_doc(text_msg)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "614e8245",
- "metadata": {},
- "source": [
- "A Claude message can be a list of image and text parts. So we've also created a helper for making the text parts."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "2bad635d",
- "metadata": {},
- "outputs": [],
- "source": [
- "q = \"In brief, what color flowers are in this image?\"\n",
- "msg = mk_msg([img_msg(img), text_msg(q)])"
+ "c.use"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "9c2a0a1f",
+ "id": "bef1304c",
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
- "The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.\n",
+ "The image shows a cute puppy, likely a Cavalier King Charles Spaniel, sitting in a grassy area surrounded by purple daisy flowers. The puppy has a friendly, curious expression on its face as it gazes directly at the camera. The contrast between the puppy's soft, fluffy fur and the vibrant flowers creates a charming and picturesque scene.\n",
"\n",
"\n",
"\n",
- "- id: msg_01GSzzitXbvkzEJtfJquzSXE\n",
- "- content: [{'text': 'The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.', 'type': 'text'}]\n",
+ "- id: msg_01535kuKhiN6Do5PTcTmTst7\n",
+ "- content: [{'text': \"The image shows a cute puppy, likely a Cavalier King Charles Spaniel, sitting in a grassy area surrounded by purple daisy flowers. The puppy has a friendly, curious expression on its face as it gazes directly at the camera. The contrast between the puppy's soft, fluffy fur and the vibrant flowers creates a charming and picturesque scene.\", 'type': 'text'}]\n",
"- model: claude-3-haiku-20240307\n",
"- role: assistant\n",
"- stop_reason: end_turn\n",
"- stop_sequence: None\n",
"- type: message\n",
- "- usage: {'input_tokens': 1665, 'output_tokens': 29}\n",
+ "- usage: {'input_tokens': 1681, 'output_tokens': 83}\n",
"\n",
"
"
],
"text/plain": [
- "ToolsBetaMessage(id='msg_01GSzzitXbvkzEJtfJquzSXE', content=[TextBlock(text='The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1665; Out: 29; Total: 1694)"
+ "ToolsBetaMessage(id='msg_01535kuKhiN6Do5PTcTmTst7', content=[TextBlock(text=\"The image shows a cute puppy, likely a Cavalier King Charles Spaniel, sitting in a grassy area surrounded by purple daisy flowers. The puppy has a friendly, curious expression on its face as it gazes directly at the camera. The contrast between the puppy's soft, fluffy fur and the vibrant flowers creates a charming and picturesque scene.\", type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1681; Out: 83; Total: 1764)"
]
},
"execution_count": null,
@@ -780,27 +693,36 @@
}
],
"source": [
- "c([msg])"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "f76150cc",
- "metadata": {},
- "source": [
- "There's not need to manually choose the type of message, since we figure that out from the data of the source data."
+ "chat = Chat(model, sp=sp)\n",
+ "chat(img)"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "50f20a38",
+ "id": "94ffc7f3",
"metadata": {},
"outputs": [
{
"data": {
+ "text/markdown": [
+ "The puppy in the image is facing the camera directly, looking straight ahead with a curious expression.\n",
+ "\n",
+ "\n",
+ "\n",
+ "- id: msg_01Ge4M4Z4J6ywg9V8cCXy2aN\n",
+ "- content: [{'text': 'The puppy in the image is facing the camera directly, looking straight ahead with a curious expression.', 'type': 'text'}]\n",
+ "- model: claude-3-haiku-20240307\n",
+ "- role: assistant\n",
+ "- stop_reason: end_turn\n",
+ "- stop_sequence: None\n",
+ "- type: message\n",
+ "- usage: {'input_tokens': 1775, 'output_tokens': 23}\n",
+ "\n",
+ "
"
+ ],
"text/plain": [
- "{'type': 'text', 'text': 'Hi'}"
+ "ToolsBetaMessage(id='msg_01Ge4M4Z4J6ywg9V8cCXy2aN', content=[TextBlock(text='The puppy in the image is facing the camera directly, looking straight ahead with a curious expression.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1775; Out: 23; Total: 1798)"
]
},
"execution_count": null,
@@ -809,35 +731,35 @@
}
],
"source": [
- "_mk_content('Hi')"
+ "chat('What direction is the puppy facing?')"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "c2e92664",
+ "id": "e25daa12",
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
- "The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.\n",
+ "The puppy in the image has a combination of colors - it has a white and brown/tan coat. The head and ears appear to be a reddish-brown color, while the body is mostly white with some tan/brown patches.\n",
"\n",
"\n",
"\n",
- "- id: msg_01ArrMvaZoXa1JTjULMentQJ\n",
- "- content: [{'text': 'The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.', 'type': 'text'}]\n",
+ "- id: msg_01JbUH6MvqWMvkF8UJVjo33z\n",
+ "- content: [{'text': 'The puppy in the image has a combination of colors - it has a white and brown/tan coat. The head and ears appear to be a reddish-brown color, while the body is mostly white with some tan/brown patches.', 'type': 'text'}]\n",
"- model: claude-3-haiku-20240307\n",
"- role: assistant\n",
"- stop_reason: end_turn\n",
"- stop_sequence: None\n",
"- type: message\n",
- "- usage: {'input_tokens': 1665, 'output_tokens': 29}\n",
+ "- usage: {'input_tokens': 1806, 'output_tokens': 53}\n",
"\n",
"
"
],
"text/plain": [
- "ToolsBetaMessage(id='msg_01ArrMvaZoXa1JTjULMentQJ', content=[TextBlock(text='The image contains purple and yellow daisy-like flowers, which appear to be daisies or a similar type of flower.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1665; Out: 29; Total: 1694)"
+ "ToolsBetaMessage(id='msg_01JbUH6MvqWMvkF8UJVjo33z', content=[TextBlock(text='The puppy in the image has a combination of colors - it has a white and brown/tan coat. The head and ears appear to be a reddish-brown color, while the body is mostly white with some tan/brown patches.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1806; Out: 53; Total: 1859)"
]
},
"execution_count": null,
@@ -846,43 +768,43 @@
}
],
"source": [
- "c([[img, q]])"
+ "chat('What color is it?')"
]
},
{
"cell_type": "markdown",
- "id": "58eda391",
+ "id": "65b52012",
"metadata": {},
"source": [
- "Claude also supports uploading an image without any text, in which case it'll make a general comment about what it sees. You can then use `Chat` to ask questions:"
+ "## XML helpers"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aa15af54",
+ "metadata": {},
+ "source": [
+ "Claude works well with XML inputs, but XML can be a bit clunky to work with manually. Therefore, we create a couple of more streamlined approaches for XML generation. You don't need to use these if you don't find them useful -- you can always just use plain strings for XML directly."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1f063c86",
+ "metadata": {},
+ "source": [
+ "An XML node contains a tag, optional children, and optional attributes. `xt` creates a tuple of these three things, which we will use to general XML shortly. Attributes are passed as kwargs; since these might conflict with reserved words in Python, you can optionally add a `_` prefix and it'll be stripped off."
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "7ed904f9",
+ "id": "180f1934",
"metadata": {},
"outputs": [
{
"data": {
- "text/markdown": [
- "The image shows a cute puppy, likely a Cavalier King Charles Spaniel, sitting in a grassy area surrounded by purple daisy flowers. The puppy has a friendly, curious expression on its face as it gazes directly at the camera. The contrast between the puppy's soft, fluffy fur and the vibrant flowers creates a charming and picturesque scene.\n",
- "\n",
- "\n",
- "\n",
- "- id: msg_01535kuKhiN6Do5PTcTmTst7\n",
- "- content: [{'text': \"The image shows a cute puppy, likely a Cavalier King Charles Spaniel, sitting in a grassy area surrounded by purple daisy flowers. The puppy has a friendly, curious expression on its face as it gazes directly at the camera. The contrast between the puppy's soft, fluffy fur and the vibrant flowers creates a charming and picturesque scene.\", 'type': 'text'}]\n",
- "- model: claude-3-haiku-20240307\n",
- "- role: assistant\n",
- "- stop_reason: end_turn\n",
- "- stop_sequence: None\n",
- "- type: message\n",
- "- usage: {'input_tokens': 1681, 'output_tokens': 83}\n",
- "\n",
- "
"
- ],
"text/plain": [
- "ToolsBetaMessage(id='msg_01535kuKhiN6Do5PTcTmTst7', content=[TextBlock(text=\"The image shows a cute puppy, likely a Cavalier King Charles Spaniel, sitting in a grassy area surrounded by purple daisy flowers. The puppy has a friendly, curious expression on its face as it gazes directly at the camera. The contrast between the puppy's soft, fluffy fur and the vibrant flowers creates a charming and picturesque scene.\", type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1681; Out: 83; Total: 1764)"
+ "('x-custom', ['hi'], {'class': 'bar'})"
]
},
"execution_count": null,
@@ -891,36 +813,77 @@
}
],
"source": [
- "chat = Chat(model, sp=sp)\n",
- "chat(img)"
+ "xt('x-custom', ['hi'], _class='bar')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9a503937",
+ "metadata": {},
+ "source": [
+ "Claudette has functions defined for some common HTML elements:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "964cbd0c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from claudette.core import div,img,h1,h2,p,hr,html"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "da6d8c0e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "a = html([\n",
+ " p('This is a paragraph'),\n",
+ " hr(),\n",
+ " img(src='http://example.prg'),\n",
+ " div([\n",
+ " h1('This is a header'),\n",
+ " h2('This is a sub-header', style='k:v'),\n",
+ " ], _class='foo')\n",
+ "])\n",
+ "a"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a7fe4c6",
+ "metadata": {},
+ "source": [
+ "Now we can convert that HTML data structure we created into XML:"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "85e1c14d",
+ "id": "80a0cde7",
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
- "The puppy in the image is facing the camera directly, looking straight ahead with a curious expression.\n",
- "\n",
- "\n",
- "\n",
- "- id: msg_01Ge4M4Z4J6ywg9V8cCXy2aN\n",
- "- content: [{'text': 'The puppy in the image is facing the camera directly, looking straight ahead with a curious expression.', 'type': 'text'}]\n",
- "- model: claude-3-haiku-20240307\n",
- "- role: assistant\n",
- "- stop_reason: end_turn\n",
- "- stop_sequence: None\n",
- "- type: message\n",
- "- usage: {'input_tokens': 1775, 'output_tokens': 23}\n",
- "\n",
- "
"
+ "```xml\n",
+ "\n",
+ " This is a paragraph
\n", + "\n", + "
\n",
+ "
\n",
+ "\n",
+ "```"
],
"text/plain": [
- "ToolsBetaMessage(id='msg_01Ge4M4Z4J6ywg9V8cCXy2aN', content=[TextBlock(text='The puppy in the image is facing the camera directly, looking straight ahead with a curious expression.', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 1775; Out: 23; Total: 1798)"
+ "This is a header
\n", + "This is a sub-header
\n", + "\n",
- "\n",
- "- id: msg_01JbUH6MvqWMvkF8UJVjo33z\n",
- "- content: [{'text': 'The puppy in the image has a combination of colors - it has a white and brown/tan coat. The head and ears appear to be a reddish-brown color, while the body is mostly white with some tan/brown patches.', 'type': 'text'}]\n",
- "- model: claude-3-haiku-20240307\n",
- "- role: assistant\n",
- "- stop_reason: end_turn\n",
- "- stop_sequence: None\n",
- "- type: message\n",
- "- usage: {'input_tokens': 1806, 'output_tokens': 53}\n",
- "\n",
- "
"
+ "```xml\n",
+ "\n",
+ "### xt\n",
"\n",
- "- id: msg_01Vr6t6QdodntSMvHthnRDBc\n",
- "- content: [{'text': 'Hello! How can I assist you today?', 'type': 'text'}]\n",
- "- model: claude-3-haiku-20240307\n",
- "- role: assistant\n",
- "- stop_reason: end_turn\n",
- "- stop_sequence: None\n",
- "- type: message\n",
- "- usage: {'input_tokens': 8, 'output_tokens': 12}\n",
+ "> xt (tag:str, c:Optional[list]=None, **kw)\n",
"\n",
- "
"
+ "*Helper to create appropriate data structure for `to_xml`.*\n",
+ "\n",
+ "| | **Type** | **Default** | **Details** |\n",
+ "| -- | -------- | ----------- | ----------- |\n",
+ "| tag | str | | XML tag name |\n",
+ "| c | Optional | None | Children |\n",
+ "| kw | | | |"
],
"text/plain": [
- "ToolsBetaMessage(id='msg_01Vr6t6QdodntSMvHthnRDBc', content=[TextBlock(text='Hello! How can I assist you today?', type='text')], model='claude-3-haiku-20240307', role='assistant', stop_reason='end_turn', stop_sequence=None, type='message', usage=In: 8; Out: 12; Total: 20)"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "c('Hi')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "d7c3a5b6",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "In: 18; Out: 64; Total: 82"
+ "---\n",
+ "\n",
+ "### xt\n",
+ "\n",
+ "> xt (tag:str, c:Optional[list]=None, **kw)\n",
+ "\n",
+ "*Helper to create appropriate data structure for `to_xml`.*\n",
+ "\n",
+ "| | **Type** | **Default** | **Details** |\n",
+ "| -- | -------- | ----------- | ----------- |\n",
+ "| tag | str | | XML tag name |\n",
+ "| c | Optional | None | Children |\n",
+ "| kw | | | |"
]
},
"execution_count": null,
@@ -1208,13 +1160,13 @@
}
],
"source": [
- "c.use"
+ "show_doc(xt)"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "0e64c6e3",
+ "id": "2795f9fc",
"metadata": {},
"outputs": [
{
@@ -1222,40 +1174,32 @@
"text/markdown": [
"---\n",
"\n",
- "### Client.stream\n",
+ "### json_to_xml\n",
"\n",
- "> Client.stream (msgs:list, sp='', temp=0, maxtok=4096,\n",
- "> stop:Optional[list[str]]=None, **kw)\n",
+ "> json_to_xml (d:dict, rnm:str)\n",
"\n",
- "*Make a call to Claude, streaming the result.*\n",
+ "*Convert `d` to XML.*\n",
"\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| msgs | list | | List of messages in the dialog |\n",
- "| sp | str | | The system prompt |\n",
- "| temp | int | 0 | Temperature |\n",
- "| maxtok | int | 4096 | Maximum tokens |\n",
- "| stop | Optional | None | Stop sequences |\n",
- "| kw | | | |"
+ "| | **Type** | **Details** |\n",
+ "| -- | -------- | ----------- |\n",
+ "| d | dict | JSON dictionary to convert |\n",
+ "| rnm | str | Root name |\n",
+ "| **Returns** | **str** | |"
],
"text/plain": [
"---\n",
"\n",
- "### Client.stream\n",
+ "### json_to_xml\n",
"\n",
- "> Client.stream (msgs:list, sp='', temp=0, maxtok=4096,\n",
- "> stop:Optional[list[str]]=None, **kw)\n",
+ "> json_to_xml (d:dict, rnm:str)\n",
"\n",
- "*Make a call to Claude, streaming the result.*\n",
+ "*Convert `d` to XML.*\n",
"\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| msgs | list | | List of messages in the dialog |\n",
- "| sp | str | | The system prompt |\n",
- "| temp | int | 0 | Temperature |\n",
- "| maxtok | int | 4096 | Maximum tokens |\n",
- "| stop | Optional | None | Stop sequences |\n",
- "| kw | | | |"
+ "| | **Type** | **Details** |\n",
+ "| -- | -------- | ----------- |\n",
+ "| d | dict | JSON dictionary to convert |\n",
+ "| rnm | str | Root name |\n",
+ "| **Returns** | **str** | |"
]
},
"execution_count": null,
@@ -1264,75 +1208,13 @@
}
],
"source": [
- "show_doc(Client.stream)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "daf74ead",
- "metadata": {},
- "source": [
- "We also define a wrapper over `messages.stream`, which is like `messages.create`, but streams the response back incrementally."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "6bf0bd41",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hello! How can I assist you today?"
- ]
- }
- ],
- "source": [
- "for o in c.stream('Hi'): print(o, end='')"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "1a7cdbc6",
- "metadata": {},
- "source": [
- "## Tool use"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "7ec35c95",
- "metadata": {},
- "source": [
- "[Tool use](https://docs.anthropic.com/claude/docs/tool-use) lets Claude use external tools.\n",
- "\n",
- "We'll use [docments](https://fastcore.fast.ai/docments.html) to make defining Python functions as ergonomic as possible. Each parameter (and the return value) should have a type, and a docments comment with the description of what it is. As an example we'll write a simple function that adds numbers together:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "562736ae",
- "metadata": {},
- "outputs": [],
- "source": [
- "def sums(\n",
- " # First thing to sum\n",
- " a:int,\n",
- " # Second thing to sum\n",
- " b:int=1\n",
- "# The sum of the inputs\n",
- ") -> int:\n",
- " \"Adds a + b.\"\n",
- " return a + b"
+ "show_doc(json_to_xml)"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "2394cfed",
+ "id": "f4f87459",
"metadata": {},
"outputs": [
{
@@ -1340,20 +1222,30 @@
"text/markdown": [
"---\n",
"\n",
- "### get_schema\n",
+ "### to_xml\n",
+ "\n",
+ "> to_xml (node:tuple, hl=False)\n",
"\n",
- "> get_schema (f:\n",
- "\n",
- "- id: msg_01StvQvvrnwaBtuUwHQLrpFt\n",
- "- content: [{'id': 'toolu_01CsuZfPAas75MkDABXAvjWD', 'input': {'a': 604542, 'b': 6458932}, 'name': 'sums', 'type': 'tool_use'}]\n",
- "- model: claude-3-haiku-20240307\n",
- "- role: assistant\n",
- "- stop_reason: tool_use\n",
- "- stop_sequence: None\n",
- "- type: message\n",
- "- usage: {'input_tokens': 414, 'output_tokens': 72}\n",
- "\n",
- "
"
- ],
- "text/plain": [
- "ToolsBetaMessage(id='msg_01StvQvvrnwaBtuUwHQLrpFt', content=[ToolUseBlock(id='toolu_01CsuZfPAas75MkDABXAvjWD', input={'a': 604542, 'b': 6458932}, name='sums', type='tool_use')], model='claude-3-haiku-20240307', role='assistant', stop_reason='tool_use', stop_sequence=None, type='message', usage=In: 414; Out: 72; Total: 486)"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "msgs = mk_msgs(pr)\n",
- "r = c(msgs, sp=sp, tools=tools)\n",
- "r"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "60a2fce0",
- "metadata": {},
- "source": [
- "When Claude decides that it should use a tool, it passes back a `ToolUseBlock` with the name of the tool to call, and the params to use.\n",
- "\n",
- "We need to append the response to the dialog so Claude knows what's happening (since it's stateless)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "46c8e981",
- "metadata": {},
- "outputs": [],
- "source": [
- "msgs.append(mk_msg(r))"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "815eaff3",
- "metadata": {},
- "source": [
- "We don't want to allow it to call just any possible function (that would be a security disaster!) so we create a *namespace* -- that is, a dictionary of allowable function names to call."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "ed48a299",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/markdown": [
- "---\n",
- "\n",
- "### call_func\n",
- "\n",
- "> call_func (tr:collections.abc.Mapping,\n",
- "> ns:Optional[collections.abc.Mapping]=None)\n",
- "\n",
- "*Call the function in the tool response `tr`, using namespace `ns`.*\n",
- "\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| tr | Mapping | | Tool use request response from Claude |\n",
- "| ns | Optional | None | Namespace to search for tools, defaults to `globals()` |"
- ],
- "text/plain": [
- "---\n",
- "\n",
- "### call_func\n",
- "\n",
- "> call_func (tr:collections.abc.Mapping,\n",
- "> ns:Optional[collections.abc.Mapping]=None)\n",
- "\n",
- "*Call the function in the tool response `tr`, using namespace `ns`.*\n",
- "\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| tr | Mapping | | Tool use request response from Claude |\n",
- "| ns | Optional | None | Namespace to search for tools, defaults to `globals()` |"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "show_doc(call_func)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "3d1f23eb",
- "metadata": {},
- "source": [
- "We can now use the function requested by Claude. We look it up in `ns`, and pass in the provided parameters."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "893f81ca",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "7063474"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "res = call_func(r, ns=ns)\n",
- "res"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "d475922d",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/markdown": [
- "---\n",
- "\n",
- "### mk_toolres\n",
- "\n",
- "> mk_toolres (r:collections.abc.Mapping, res=None,\n",
- "> ns:Optional[collections.abc.Mapping]=None)\n",
- "\n",
- "*Create a `tool_result` message from response `r`.*\n",
- "\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| r | Mapping | | Tool use request response from Claude |\n",
- "| res | NoneType | None | The result of calling the tool (calculated with `call_func` by default) |\n",
- "| ns | Optional | None | Namespace to search for tools |"
- ],
- "text/plain": [
- "---\n",
- "\n",
- "### mk_toolres\n",
- "\n",
- "> mk_toolres (r:collections.abc.Mapping, res=None,\n",
- "> ns:Optional[collections.abc.Mapping]=None)\n",
- "\n",
- "*Create a `tool_result` message from response `r`.*\n",
- "\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| r | Mapping | | Tool use request response from Claude |\n",
- "| res | NoneType | None | The result of calling the tool (calculated with `call_func` by default) |\n",
- "| ns | Optional | None | Namespace to search for tools |"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "show_doc(mk_toolres)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "5a57d1ca",
- "metadata": {},
- "source": [
- "In order to tell Claude the result of the tool call, we pass back a `tool_result` message, created by calling `call_func`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "f13de1fc",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "{'role': 'user',\n",
- " 'content': [{'type': 'tool_result',\n",
- " 'tool_use_id': 'toolu_01CsuZfPAas75MkDABXAvjWD',\n",
- " 'content': '7063474'}]}"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "tr = mk_toolres(r, res=res, ns=ns)\n",
- "tr"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "faf4fe37",
- "metadata": {},
- "source": [
- "We add this to our dialog, and now Claude has all the information it needs to answer our question."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "eed99502",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "'The sum of 604542 and 6458932 is 7063474.'"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "msgs.append(tr)\n",
- "contents(c(msgs, sp=sp, tools=tools))"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "65b52012",
- "metadata": {},
- "source": [
- "## XML helpers"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "aa15af54",
- "metadata": {},
- "source": [
- "Claude works well with XML inputs, but XML can be a bit clunky to work with manually. Therefore, we create a couple of more streamlined approaches for XML generation. You don't need to use these if you don't find them useful -- you can always just use plain strings for XML directly."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "26f66da9",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/markdown": [
- "---\n",
- "\n",
- "### xt\n",
- "\n",
- "> xt (tag:str, c:Optional[list]=None, **kw)\n",
- "\n",
- "*Helper to create appropriate data structure for `to_xml`.*\n",
- "\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| tag | str | | XML tag name |\n",
- "| c | Optional | None | Children |\n",
- "| kw | | | |"
- ],
- "text/plain": [
- "---\n",
- "\n",
- "### xt\n",
- "\n",
- "> xt (tag:str, c:Optional[list]=None, **kw)\n",
- "\n",
- "*Helper to create appropriate data structure for `to_xml`.*\n",
- "\n",
- "| | **Type** | **Default** | **Details** |\n",
- "| -- | -------- | ----------- | ----------- |\n",
- "| tag | str | | XML tag name |\n",
- "| c | Optional | None | Children |\n",
- "| kw | | | |"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "show_doc(xt)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "1f063c86",
- "metadata": {},
- "source": [
- "An XML node contains a tag, optional children, and optional attributes. `xt` creates a tuple of these three things, which we will use to general XML shortly. Attributes are passed as kwargs; since these might conflict with reserved words in Python, you can optionally add a `_` prefix and it'll be stripped off."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "180f1934",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "('x-custom', ['hi'], {'class': 'bar'})"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "xt('x-custom', ['hi'], _class='bar')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "59329ea3",
- "metadata": {},
- "outputs": [],
- "source": [
- "from claudette.core import div,img,h1,h2,p,hr,html"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "9a503937",
- "metadata": {},
- "source": [
- "If you have to use a lot of tags of the same type, it's convenient to use `partial` to create specialised functions for them. Here, we're creating functions for some common HTML tags. Here's an example of using them:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "b6122acf",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "('html',\n",
- " [('p', 'This is a paragraph', {}),\n",
- " ('hr', None, {}),\n",
- " ('img', None, {'src': 'http://example.prg'}),\n",
- " ('div',\n",
- " [('h1', 'This is a header', {}),\n",
- " ('h2', 'This is a sub-header', {'style': 'k:v'})],\n",
- " {'class': 'foo'})],\n",
- " {})"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "a = html([\n",
- " p('This is a paragraph'),\n",
- " hr(),\n",
- " img(src='http://example.prg'),\n",
- " div([\n",
- " h1('This is a header'),\n",
- " h2('This is a sub-header', style='k:v'),\n",
- " ], _class='foo')\n",
- "])\n",
- "a"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "15807ed7",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/markdown": [
- "---\n",
- "\n",
- "### hl_md\n",
- "\n",
- "> hl_md (s, lang='xml')\n",
- "\n",
- "*Syntax highlight `s` using `lang`.*"
- ],
- "text/plain": [
- "---\n",
- "\n",
- "### hl_md\n",
- "\n",
- "> hl_md (s, lang='xml')\n",
- "\n",
- "*Syntax highlight `s` using `lang`.*"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "show_doc(hl_md)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "79155289",
- "metadata": {},
- "source": [
- "When we display XML in a notebook, it's nice to highlight it, so we create a function to simplify that:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "eb4907fe",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/markdown": [
- "```xml\n",
- "This is a paragraph
\n", - "\n", - "
\n",
- "
\n",
- "\n",
- "```"
- ],
- "text/plain": [
- "