Claude is a large language model (LLM) developed by Anthropic, able to understand and generate human-like text based on a vast corpus of data. Named after Claude Shannon, the father of information theory, this model aims to set new standards in AI language processing by leveraging ethical AI principles and enhancing the safety of automated interactions.
Claude is considered a state of the art LLM, competitive with industry leaders like OpenAI’s GPT-4. It enables applications ranging from text summarization, content creation, code creation, and conversational agents. With extensive safety features, Claude minimizes risks associated with AI misuse and focuses on responsible deployment, ensuring that AI advancements align positively with human values.
This is part of a series of articles about Anthropic Claude
In this article:
The Claude API, developed by Anthropic, allows developers to integrate Claude's advanced language models into their applications for a wide range of tasks, such as text generation, summarization, and conversational agents. The API supports various models, providing flexibility depending on the complexity and speed required for the task.
It is available with scalable access options, including pay-as-you-go pricing and higher-volume custom plans for enterprise use. The API is designed to prioritize safety and ethical use, ensuring secure and trustworthy deployments.
Features of the Claude API:
The pricing for the Claude API by Anthropic is based on a pay-as-you-go model, with rates that vary depending on the complexity of the model used:
Claude 3.5 Sonnet:
Claude 3 Opus:
Claude 3 Haiku:
**Claude 3 Sonnet **(legacy):
Claude Instant 1.2:
Anthropic enforces rate limits on the Claude API to ensure fair usage and prevent misuse. These limits include both usage limits and rate limits.
Usage limits are set based on different tiers that determine the maximum cost an organization can incur monthly. As you reach certain thresholds in usage, your organization can automatically advance to higher tiers, which allow for more extensive use. Each tier has specific requirements:
Once you reach the monthly usage limit of your tier, you must either wait for the next month or qualify for the next tier to continue using the API.
Rate limits are applied to control the number of requests and tokens used over specific time intervals, helping to manage the API's load. These limits vary by model and tier:
For example, the Claude 3.5 Sonnet model allows 5 requests per minute, 20,000 tokens per minute, and 300,000 tokens per day in the Free tier. Higher tiers may offer increased limits.
If a rate limit is exceeded, the API will return a 429 error, indicating that you have surpassed the allowed usage. The API response will include headers showing the current usage and when the limits will reset, allowing users to manage their requests accordingly.
To begin using the Anthropic Claude API, follow these steps to set up your environment and make your first API call.
Before diving into code, it's recommended to start with the Workbench, a web-based interface within the Anthropic Console that allows you to experiment with Claude's capabilities interactively.
Log into the Anthropic Console and navigate to the Workbench.
Ask Claude a question by typing it into the **User **section. For example, you could ask, "Why is the Earth round?"
Run the query and observe the response on the right side. You can tweak the response format by setting a System Prompt. For example, if you want Claude to respond in a playful rapper form, you can use the system prompt:
``` You are a hip rapper. Respond with clever rap lines. ```
When you click Run again, Claude's response will be adjusted according to the prompt.
Convert your Workbench session into code by clicking Get Code. This will generate the Python or TypeScript code that replicates your session, which you can then integrate into your application.
Next, install the necessary SDK to interface with the API. Anthropic provides SDKs for Python (3.7+) and TypeScript (4.5+).
Python:
Create a virtual environment to manage your dependencies:
``` python -m venv claude-env ```
Activate the virtual environment:
On macOS or Linux: ``` source claude-env/bin/activate ``` On Windows: ``` claude-env\Scripts\activate ```
Install the Anthropic SDK:
``` pip install anthropic ```
Each API call requires an API key for authentication. The SDK expects this key to be set as an environment variable named
ANTHROPIC_API_KEYmacOS and Linux:
export ANTHROPIC_API_KEY='My-API-key'
Windows:
set ANTHROPIC_API_KEY='My-API-key'
Alternatively, you can pass the API key directly to the client when initializing it in your code.
To make a basic request to the Claude API and receive a response, you can use the following code snippet. This example shows how to send a simple message to Claude and receive a reply.
Python example:
import anthropic # Initialize the Claude client client = anthropic.Anthropic() # Send a basic message to Claude message = client.messages.create( model="claude-3-5-sonnet-20240620", max_tokens=1024, messages=[ {"role": "user", "content": "Hey, Claude"} ], ) # Print the response print(message.content)
Response example:
{ "id": "msg_01XFDUDYJgAACzvnptvVoYEL", "type": "message", "role": "assistant", "content": [ { "type": "text", "text": "Hey there!" } ], "model": "claude-3-5-sonnet-20240620", "stop_reason": "end_turn", "usage": { "input_tokens": 12, "output_tokens": 6 } }
In this example, the user sends a message saying "Hello, Claude," and the API responds with "Hello!" This basic interaction demonstrates how to send a simple prompt and receive a straightforward reply.
The Claude API supports multiple conversational turns by maintaining a stateless API, meaning that each request must include the full conversation history. This allows developers to build complex interactions over time.
Python example:
import anthropic # Initialize the Claude client client = anthropic.Anthropic() # Send a series of messages to create a conversation message = client.messages.create( model="claude-3-5-sonnet-20240620", max_tokens=1024, messages=[ {"role": "user", "content": "Hey, Claude"}, {"role": "assistant", "content": "Hey there!"}, {"role": "user", "content": "Explain what is an LLM."} ], ) # Print the response print(message.content)
Response example:
{ "id": "msg_018gCsTGsXkYJVqYPxTgDHBU", "type": "message", "role": "assistant", "content": [ { "type": "text", "text": "Sure, here's a description of a large language model (LLM)..." } ], "stop_reason": "end_turn", "usage": { "input_tokens": 50, "output_tokens": 500 } }
This example builds a conversation with Claude, where the user asks multiple questions, and Claude responds accordingly, maintaining the context of the conversation.
You can influence Claude's response by pre-filling part of the response content. This is particularly useful when you want to guide Claude towards a specific type of answer, such as multiple-choice responses.
Python Example:
import anthropic # Initialize the Claude client client = anthropic.Anthropic() # Send a multiple-choice question and guide Claude's response message = client.messages.create( model="claude-3-5-sonnet-20240620", max_tokens=1, messages=[ {"role": "user", "content": "What is the Greek for fear? (A) Arachnea, (B) Philosophia, (C) Phobia"}, {"role": "assistant", "content": "The answer is ("} ] ) # Print the response print(message)
Response example:
{ "id": "msg_01Q8Faay6S7QPTvEUUQARt7h", "type": "message", "role": "assistant", "content": [ { "type": "text", "text": "C" } ], "model": "claude-3-5-sonnet-20240620", "stop_reason": "max_tokens", "stop_sequence": null, "usage": { "input_tokens": 50, "output_tokens": 1 } }
In this example, Claude is prompted with a multiple-choice question about the Latin name for ants, and the response is guided to produce a single character, "C," indicating the correct choice.
Claude can process both text and images in a request. For images, you need to encode them in base64 and include them in the API call. Claude supports various image formats like JPEG, PNG, GIF, and WebP.
Python example:
import anthropic import base64 import httpx # Download and encode the image image_url = "https://en.wikipedia.org/wiki/Wolf#/media/File:Eurasian_wolf_2.jpg" image_media_type = "image/jpeg" image_data = base64.b64encode(httpx.get(image_url).content).decode("utf-8") # Initialize the Claude client and send an image for analysis client = anthropic.Anthropic() message = client.messages.create( model="claude-3-5-sonnet-20240620", max_tokens=1024, messages=[ { "role": "user", "content": [ { "type": "image", "source": { "type": "base64", "media_type": image_media_type, "data": image_data, }, }, {"type": "text", "text": "What type of animal is in this image?"} ], } ], ) # Print the response print(message)
Response example:
{ "id": "msg_01EcyWo6m4hyW8KHs2y2pei5", "type": "message", "role": "assistant", "content": [ { "type": "text", "text": "This image shows a wolf, specifically a Eurasian wolf at Polar Zoo in Bardu, Norway. The wolf is shown walking on the snow, with its paws partially covered by the snow. The image is focused on capturing the general idea and features of a wolf." } ], "model": "claude-3-5-sonnet-20240620", "stop_reason": "end_turn", "stop_sequence": null, "usage": { "input_tokens": 2000, "output_tokens": 100 } }
To see what you can start building today with GPTScript, visit our docs at https://gptscript-ai.github.io/knowledge/. For a great example of RAG at work on GPTScript check out our blog GPTScript Knowledge Tool v0.3 Introduces One-Time Configuration for Embedding Model Providers.