Zum Hauptinhalt springen

AWS Bedrock

ALLE Bedrock-Modelle (Anthropic, Meta, Deepseek, Mistral, Amazon, etc.) WERDEN UNTERSTÜTZT

EigenschaftDetails
BeschreibungAmazon Bedrock ist ein vollständig verwalteter Dienst, der eine Auswahl an leistungsstarken Basismodellen (FMs) bietet.
Provider-Routing in LiteLLMbedrock/, bedrock/converse/, bedrock/invoke/, bedrock/converse_like/, bedrock/llama/, bedrock/deepseek_r1/
Provider-DokumentationAmazon Bedrock ↗
Unterstützte OpenAI-Endpunkte/chat/completions, /completions, /embeddings, /images/generations
Rerank-Endpunkt/rerank
Passthrough-EndpunktUnterstützt

LiteLLM erfordert, dass boto3 auf Ihrem System für Bedrock-Anfragen installiert ist

pip install boto3>=1.28.57
Info

Für Amazon Nova Modelle: Upgrade auf v1.53.5+

Info

LiteLLM verwendet boto3 zur Authentifizierung. Alle diese Optionen werden unterstützt - https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#credentials.

Verwendung​

Open In Colab
import os
from litellm import completion

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

response = completion(
  model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
  messages=[{ "content": "Hello, how are you?","role": "user"}]
)

LiteLLM Proxy-Nutzung​

So rufen Sie Bedrock mit dem LiteLLM Proxy Server auf

1. config.yaml einrichten​

model_list:
  - model_name: bedrock-claude-3-5-sonnet
    litellm_params:
      model: bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0
      aws_access_key_id: os.environ/AWS_ACCESS_KEY_ID
      aws_secret_access_key: os.environ/AWS_SECRET_ACCESS_KEY
      aws_region_name: os.environ/AWS_REGION_NAME

Alle möglichen Authentifizierungsparameter

aws_access_key_id: Optional[str],
aws_secret_access_key: Optional[str],
aws_session_token: Optional[str],
aws_region_name: Optional[str],
aws_session_name: Optional[str],
aws_profile_name: Optional[str],
aws_role_name: Optional[str],
aws_web_identity_token: Optional[str],
aws_bedrock_runtime_endpoint: Optional[str],

2. Proxy starten​

litellm --config /path/to/config.yaml

3. Testen​

curl --location 'http://0.0.0.0:4000/chat/completions' \
--header 'Content-Type: application/json' \
--data ' {
      "model": "bedrock-claude-v1",
      "messages": [
        {
          "role": "user",
          "content": "what llm are you"
        }
      ]
    }
'

Temperatur, Top-p usw. einstellen​

import os
from litellm import completion

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

response = completion(
  model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
  messages=[{ "content": "Hello, how are you?","role": "user"}],
  temperature=0.7,
  top_p=1
)

Provider-spezifische Parameter übergeben​

Wenn Sie einen Nicht-OpenAI-Parameter an litellm übergeben, gehen wir davon aus, dass es sich um einen provider-spezifischen Parameter handelt und senden ihn als Kwarg im Anforderungsbody. Mehr erfahren

import os
from litellm import completion

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

response = completion(
  model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
  messages=[{ "content": "Hello, how are you?","role": "user"}],
  top_k=1 # 👈 PROVIDER-SPECIFIC PARAM
)

Verwendung - Funktionsaufrufe / Tool-Aufrufe​

LiteLLM unterstützt Tool-Aufrufe über die Converse- und Invoke-APIs von Bedrock.

from litellm import completion

# set env
os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Get the current weather in a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    },
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                },
                "required": ["location"],
            },
        },
    }
]
messages = [{"role": "user", "content": "What's the weather like in Boston today?"}]

response = completion(
    model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
# Add any assertions, here to check response args
print(response)
assert isinstance(response.choices[0].message.tool_calls[0].function.name, str)
assert isinstance(
    response.choices[0].message.tool_calls[0].function.arguments, str
)

Verwendung - Vision​

from litellm import completion

# set env
os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""


def encode_image(image_path):
    import base64

    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")


image_path = "../proxy/cached_logo.jpg"
# Getting the base64 string
base64_image = encode_image(image_path)
resp = litellm.completion(
    model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Whats in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "data:image/jpeg;base64," + base64_image
                    },
                },
            ],
        }
    ],
)
print(f"\nResponse: {resp}")

Verwendung - 'Denk'- / 'Reasoning-Inhalt'​

Dies wird derzeit nur für Anthropic's Claude 3.7 Sonnet + Deepseek R1 unterstützt.

Funktioniert ab v1.61.20+.

Gibt 2 neue Felder im message- und delta-Objekt zurück

  • reasoning_content - string - Der Reasoning-Inhalt der Antwort
  • thinking_blocks - Liste von Objekten (nur Anthropic) - Die Denkblöcke der Antwort

Jedes Objekt hat die folgenden Felder

  • type - Literal["thinking"]- Der Typ des Denkblocks
  • thinking - string - Das Denken der Antwort. Wird auch in reasoning_content zurückgegeben
  • signature - string - Eine Base64-kodierte Zeichenkette, die von Anthropic zurückgegeben wird.

Die signature ist bei nachfolgenden Aufrufen von Anthropic erforderlich, wenn 'thinking'-Inhalt übergeben wird (nur erforderlich, um thinking mit Tool-Aufrufen zu verwenden). Mehr erfahren

from litellm import completion

# set env
os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""


resp = completion(
    model="bedrock/us.anthropic.claude-3-7-sonnet-20250219-v1:0",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
    reasoning_effort="low",
)

print(resp)

Erwartete Antwort

Identisch mit Anthropic API-Antwort.

{
    "id": "chatcmpl-c661dfd7-7530-49c9-b0cc-d5018ba4727d",
    "created": 1740640366,
    "model": "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
    "object": "chat.completion",
    "system_fingerprint": null,
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "message": {
                "content": "The capital of France is Paris. It's not only the capital city but also the largest city in France, serving as the country's major cultural, economic, and political center.",
                "role": "assistant",
                "tool_calls": null,
                "function_call": null,
                "reasoning_content": "The capital of France is Paris. This is a straightforward factual question.",
                "thinking_blocks": [
                    {
                        "type": "thinking",
                        "thinking": "The capital of France is Paris. This is a straightforward factual question.",
                        "signature": "EqoBCkgIARABGAIiQL2UoU0b1OHYi+yCHpBY7U6FQW8/FcoLewocJQPa2HnmLM+NECy50y44F/kD4SULFXi57buI9fAvyBwtyjlOiO0SDE3+r3spdg6PLOo9PBoMma2ku5OTAoR46j9VIjDRlvNmBvff7YW4WI9oU8XagaOBSxLPxElrhyuxppEn7m6bfT40dqBSTDrfiw4FYB4qEPETTI6TA6wtjGAAqmFqKTo="
                    }
                ]
            }
        }
    ],
    "usage": {
        "completion_tokens": 64,
        "prompt_tokens": 42,
        "total_tokens": 106,
        "completion_tokens_details": null,
        "prompt_tokens_details": null
    }
}

Übergib thinking an Anthropic-Modelle​

Identisch mit Anthropic API-Antwort.

Verwendung - Strukturierte Ausgabe / JSON-Modus​

from litellm import completion
import os 
from pydantic import BaseModel

# set env
os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

class CalendarEvent(BaseModel):
  name: str
  date: str
  participants: list[str]

class EventsList(BaseModel):
    events: list[CalendarEvent]

response = completion(
  model="bedrock/anthropic.claude-3-7-sonnet-20250219-v1:0", # specify invoke via `bedrock/invoke/anthropic.claude-3-7-sonnet-20250219-v1:0`
  response_format=EventsList,
  messages=[
    {"role": "system", "content": "You are a helpful assistant designed to output JSON."},
    {"role": "user", "content": "Who won the world series in 2020?"}
  ],
)
print(response.choices[0].message.content)

Verwendung - Latenzoptimierte Inferenz​

Gültig ab v1.65.1+

from litellm import completion

response = completion(
    model="bedrock/anthropic.claude-3-7-sonnet-20250219-v1:0",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
    performanceConfig={"latency": "optimized"},
)

Verwendung - Bedrock Guardrails​

Beispiel für die Verwendung von Bedrock Guardrails mit LiteLLM

from litellm import completion

# set env
os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

response = completion(
    model="anthropic.claude-v2",
    messages=[
        {
            "content": "where do i buy coffee from? ",
            "role": "user",
        }
    ],
    max_tokens=10,
    guardrailConfig={
        "guardrailIdentifier": "ff6ujrregl1q", # The identifier (ID) for the guardrail.
        "guardrailVersion": "DRAFT",           # The version of the guardrail.
        "trace": "disabled",                   # The trace behavior for the guardrail. Can either be "disabled" or "enabled"
    },
)

Verwendung - "Assistant Pre-fill"​

Wenn Sie Anthropic's Claude mit Bedrock verwenden, können Sie "Worte in Claudes Mund legen", indem Sie eine Nachricht mit der Rolle assistant als letztes Element im messages-Array einfügen.

[!WICHTIG]Die zurückgegebene Vervollständigung wird Ihren "Pre-fill"-Text *nicht* enthalten, da er Teil des Prompts selbst ist. Stellen Sie sicher, dass Sie Claudes Vervollständigung mit Ihrem Pre-fill voranstellen.

import os
from litellm import completion

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

messages = [
    {"role": "user", "content": "How do you say 'Hello' in German? Return your answer as a JSON object, like this:\n\n{ \"Hello\": \"Hallo\" }"},
    {"role": "assistant", "content": "{"},
]
response = completion(model="bedrock/anthropic.claude-v2", messages=messages)

Beispiel-Prompt an Claude gesendet​


Human: How do you say 'Hello' in German? Return your answer as a JSON object, like this:

{ "Hello": "Hallo" }

Assistant: {

Verwendung - "System"-Nachrichten​

Wenn Sie Anthropic's Claude 2.1 mit Bedrock verwenden, werden system-Rollen-Nachrichten korrekt für Sie formatiert.

import os
from litellm import completion

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

messages = [
    {"role": "system", "content": "You are a snarky assistant."},
    {"role": "user", "content": "How do I boil water?"},
]
response = completion(model="bedrock/anthropic.claude-v2:1", messages=messages)

Beispiel-Prompt an Claude gesendet​

You are a snarky assistant.

Human: How do I boil water?

Assistant:

Verwendung - Streaming​

import os
from litellm import completion

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

response = completion(
  model="bedrock/anthropic.claude-instant-v1",
  messages=[{ "content": "Hello, how are you?","role": "user"}],
  stream=True
)
for chunk in response:
  print(chunk)

Beispiel-Streaming-Ausgabe-Chunk​

{
  "choices": [
    {
      "finish_reason": null,
      "index": 0,
      "delta": {
        "content": "ase can appeal the case to a higher federal court. If a higher federal court rules in a way that conflicts with a ruling from a lower federal court or conflicts with a ruling from a higher state court, the parties involved in the case can appeal the case to the Supreme Court. In order to appeal a case to the Sup"
      }
    }
  ],
  "created": null,
  "model": "anthropic.claude-instant-v1",
  "usage": {
    "prompt_tokens": null,
    "completion_tokens": null,
    "total_tokens": null
  }
}

Cross-Region-Inferenz​

LiteLLM unterstützt Cross-Region-Inferenz von Bedrock für alle unterstützten Bedrock-Modelle.

from litellm import completion 
import os 


os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""


litellm.set_verbose = True #  👈 SEE RAW REQUEST 

response = completion(
    model="bedrock/us.anthropic.claude-3-haiku-20240307-v1:0",
    messages=messages,
    max_tokens=10,
    temperature=0.1,
)

print("Final Response: {}".format(response))

Route 'converse' / 'invoke' festlegen​

Info

Unterstützt ab LiteLLM Version v1.53.5

LiteLLM verwendet standardmäßig die invoke-Route. LiteLLM verwendet die converse-Route für Bedrock-Modelle, die dies unterstützen.

Um die Route explizit festzulegen, verwenden Sie bedrock/converse/<model> oder bedrock/invoke/<model>.

Z.B.

from litellm import completion

completion(model="bedrock/converse/us.amazon.nova-pro-v1:0")

Abwechselnde Benutzer-/Assistentennachrichten​

Verwenden Sie user_continue_message, um eine Standard-Benutzernachricht hinzuzufügen, für Fälle (z. B. Autogen), in denen der Client möglicherweise keinen abwechselnden Benutzer-/Assistentennachrichten folgt, die mit einer Benutzernachricht beginnen und enden.

model_list:
  - model_name: "bedrock-claude"
    litellm_params:
      model: "bedrock/anthropic.claude-instant-v1"
      user_continue_message: {"role": "user", "content": "Please continue"}

ODER

Stellen Sie einfach litellm.modify_params=True ein und LiteLLM wird dies automatisch mit einer Standard-user_continue_message behandeln.

model_list:
  - model_name: "bedrock-claude"
    litellm_params:
      model: "bedrock/anthropic.claude-instant-v1"

litellm_settings:
   modify_params: true

Testen Sie es!

curl -X POST 'http://0.0.0.0:4000/chat/completions' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer sk-1234' \
-d '{
    "model": "bedrock-claude",
    "messages": [{"role": "assistant", "content": "Hey, how's it going?"}]
}'

Verwendung - PDF / Dokumentenverständnis​

LiteLLM unterstützt Dokumentenverständnis für Bedrock-Modelle - AWS Bedrock Docs.

Info

LiteLLM unterstützt ALLE Bedrock-Dokumenttypen -

Z.B.: "pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"

Sie können diese auch entweder als image_url oder als base64 übergeben

URL​

from litellm.utils import supports_pdf_input, completion

# set aws credentials
os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""


# pdf url
image_url = "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf"

# Download the file
response = requests.get(url)
file_data = response.content

encoded_file = base64.b64encode(file_data).decode("utf-8")

# model
model = "bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0"

image_content = [
    {"type": "text", "text": "What's this file about?"},
    {
        "type": "file",
        "file": {
            "file_data": f"data:application/pdf;base64,{encoded_file}", # 👈 PDF
        }
    },
]


if not supports_pdf_input(model, None):
    print("Model does not support image input")

response = completion(
    model=model,
    messages=[{"role": "user", "content": image_content}],
)
assert response is not None

base64​

from litellm.utils import supports_pdf_input, completion

# set aws credentials
os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""


# pdf url
image_url = "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf"
response = requests.get(url)
file_data = response.content

encoded_file = base64.b64encode(file_data).decode("utf-8")
base64_url = f"data:application/pdf;base64,{encoded_file}"

# model
model = "bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0"

image_content = [
    {"type": "text", "text": "What's this file about?"},
    {
        "type": "image_url",
        "image_url": base64_url, # OR {"url": base64_url}
    },
]


if not supports_pdf_input(model, None):
    print("Model does not support image input")

response = completion(
    model=model,
    messages=[{"role": "user", "content": image_content}],
)
assert response is not None

Bedrock Importierte Modelle (Deepseek, Deepseek R1)​

Deepseek R1​

Dies ist eine separate Route, da das Chat-Template anders ist.

EigenschaftDetails
Provider-Routebedrock/deepseek_r1/{model_arn}
Provider-DokumentationBedrock Importierte Modelle, Deepseek Bedrock Importiertes Modell
from litellm import completion
import os

response = completion(
    model="bedrock/deepseek_r1/arn:aws:bedrock:us-east-1:086734376398:imported-model/r4c4kewx2s0n",  # bedrock/deepseek_r1/{your-model-arn}
    messages=[{"role": "user", "content": "Tell me a joke"}],
)

Deepseek (nicht R1)​

EigenschaftDetails
Provider-Routebedrock/llama/{model_arn}
Provider-DokumentationBedrock Importierte Modelle, Deepseek Bedrock Importiertes Modell

Verwenden Sie diese Route, um Bedrock-Importierte Modelle aufzurufen, die dem llama Invoke Request / Response-Format folgen

from litellm import completion
import os

response = completion(
    model="bedrock/llama/arn:aws:bedrock:us-east-1:086734376398:imported-model/r4c4kewx2s0n",  # bedrock/llama/{your-model-arn}
    messages=[{"role": "user", "content": "Tell me a joke"}],
)

Provisioned Throughput Modelle​

Um Provisioned Throughput Bedrock-Modelle zu verwenden, übergeben Sie

  • model=bedrock/<basis-modell>, z.B. model=bedrock/anthropic.claude-v2. Legen Sie model auf eines der unterstützten AWS-Modelle fest
  • model_id=provisioned-model-arn

Abschluss

import litellm
response = litellm.completion(
    model="bedrock/anthropic.claude-instant-v1",
    model_id="provisioned-model-arn",
    messages=[{"content": "Hello, how are you?", "role": "user"}]
)

Einbettung

import litellm
response = litellm.embedding(
    model="bedrock/amazon.titan-embed-text-v1",
    model_id="provisioned-model-arn",
    input=["hi"],
)

Unterstützte AWS Bedrock Modelle​

LiteLLM unterstützt ALLE Bedrock-Modelle.

Hier ist ein Beispiel für die Verwendung eines Bedrock-Modells mit LiteLLM. Eine vollständige Liste finden Sie in der Modellkostenübersicht

ModellnameBefehl
Deepseek R1completion(model='bedrock/us.deepseek.r1-v1:0', messages=messages)
Anthropic Claude-V3.5 Sonnetcompletion(model='bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0', messages=messages)
Anthropic Claude-V3 Sonnetcompletion(model='bedrock/anthropic.claude-3-sonnet-20240229-v1:0', messages=messages)
Anthropic Claude-V3 Haikucompletion(model='bedrock/anthropic.claude-3-haiku-20240307-v1:0', messages=messages)
Anthropic Claude-V3 Opuscompletion(model='bedrock/anthropic.claude-3-opus-20240229-v1:0', messages=messages)
Anthropic Claude-V2.1completion(model='bedrock/anthropic.claude-v2:1', messages=messages)
Anthropic Claude-V2completion(model='bedrock/anthropic.claude-v2', messages=messages)
Anthropic Claude-Instant V1completion(model='bedrock/anthropic.claude-instant-v1', messages=messages)
Meta llama3-1-405bcompletion(model='bedrock/meta.llama3-1-405b-instruct-v1:0', messages=messages)
Meta llama3-1-70bcompletion(model='bedrock/meta.llama3-1-70b-instruct-v1:0', messages=messages)
Meta llama3-1-8bcompletion(model='bedrock/meta.llama3-1-8b-instruct-v1:0', messages=messages)
Meta llama3-70bcompletion(model='bedrock/meta.llama3-70b-instruct-v1:0', messages=messages)
Meta llama3-8bcompletion(model='bedrock/meta.llama3-8b-instruct-v1:0', messages=messages)
Amazon Titan Litecompletion(model='bedrock/amazon.titan-text-lite-v1', messages=messages)
Amazon Titan Expresscompletion(model='bedrock/amazon.titan-text-express-v1', messages=messages)
Cohere Commandcompletion(model='bedrock/cohere.command-text-v14', messages=messages)
AI21 J2-Midcompletion(model='bedrock/ai21.j2-mid-v1', messages=messages)
AI21 J2-Ultracompletion(model='bedrock/ai21.j2-ultra-v1', messages=messages)
AI21 Jamba-Instructcompletion(model='bedrock/ai21.jamba-instruct-v1:0', messages=messages)
Meta Llama 2 Chat 13bcompletion(model='bedrock/meta.llama2-13b-chat-v1', messages=messages)
Meta Llama 2 Chat 70bcompletion(model='bedrock/meta.llama2-70b-chat-v1', messages=messages)
Mistral 7B Instructcompletion(model='bedrock/mistral.mistral-7b-instruct-v0:2', messages=messages)
Mixtral 8x7B Instructcompletion(model='bedrock/mistral.mixtral-8x7b-instruct-v0:1', messages=messages)

Bedrock Embedding​

API-Schlüssel​

Dies kann als Umgebungsvariable festgelegt oder als Parameter für litellm.embedding() übergeben werden

import os
os.environ["AWS_ACCESS_KEY_ID"] = ""        # Access key
os.environ["AWS_SECRET_ACCESS_KEY"] = ""    # Secret access key
os.environ["AWS_REGION_NAME"] = ""           # us-east-1, us-east-2, us-west-1, us-west-2

Verwendung​

from litellm import embedding
response = embedding(
    model="bedrock/amazon.titan-embed-text-v1",
    input=["good morning from litellm"],
)
print(response)

Unterstützte AWS Bedrock Embedding-Modelle​

ModellnameVerwendungUnterstützte zusätzliche OpenAI-Parameter
Titan Embeddings V2embedding(model="bedrock/amazon.titan-embed-text-v2:0", input=input)hier
Titan Embeddings - V1embedding(model="bedrock/amazon.titan-embed-text-v1", input=input)hier
Titan Multimodal Embeddingsembedding(model="bedrock/amazon.titan-embed-image-v1", input=input)hier
Cohere Embeddings - Englischembedding(model="bedrock/cohere.embed-english-v3", input=input)hier
Cohere Embeddings - Mehrsprachigembedding(model="bedrock/cohere.embed-multilingual-v3", input=input)hier

Erweitert - Nicht unterstützte Parameter löschen​

Erweitert - Modell-/Provider-spezifische Parameter übergeben​

Bilderzeugung​

Verwenden Sie dies für Stable Diffusion und Amazon Nova Canvas auf Bedrock

Verwendung​

import os
from litellm import image_generation

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

response = image_generation(
            prompt="A cute baby sea otter",
            model="bedrock/stability.stable-diffusion-xl-v0",
        )
print(f"response: {response}")

Optionale Parameter festlegen

import os
from litellm import image_generation

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

response = image_generation(
            prompt="A cute baby sea otter",
            model="bedrock/stability.stable-diffusion-xl-v0",
            ### OPENAI-COMPATIBLE ###
            size="128x512", # width=128, height=512
            ### PROVIDER-SPECIFIC ### see `AmazonStabilityConfig` in bedrock.py for all params
            seed=30
        )
print(f"response: {response}")

Unterstützte AWS Bedrock Bilderzeugungsmodelle​

ModellnameFunktionsaufruf
Stable Diffusion 3 - v0embedding(model="bedrock/stability.stability.sd3-large-v1:0", prompt=prompt)
Stable Diffusion - v0embedding(model="bedrock/stability.stable-diffusion-xl-v0", prompt=prompt)
Stable Diffusion - v0embedding(model="bedrock/stability.stable-diffusion-xl-v1", prompt=prompt)

Rerank API​

Verwenden Sie die Rerank-API von Bedrock im Cohere /rerank-Format.

Unterstützte Cohere Rerank-Parameter

  • model - das Basismodell-ARN
  • query - die Abfrage, gegen die neu sortiert werden soll
  • documents - die Liste der zu neu sortierenden Dokumente
  • top_n - die Anzahl der zurückzugebenden Ergebnisse
from litellm import rerank
import os 

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

response = rerank(
    model="bedrock/arn:aws:bedrock:us-west-2::foundation-model/amazon.rerank-v1:0", # provide the model ARN - get this here https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock/client/list_foundation_models.html
    query="hello",
    documents=["hello", "world"],
    top_n=2,
)

print(response)

Bedrock Application Inference Profile​

Verwenden Sie das Bedrock Application Inference Profile, um Kosten für Projekte auf AWS zu verfolgen.

Sie können es entweder im Modellnamen übergeben - model="bedrock/arn:... oder als separaten model_id="arn:.. Parameter.

Eingestellt über model_id​

from litellm import completion
import os 

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

response = completion(
    model="bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
    messages=[{"role": "user", "content": "Hello, how are you?"}],
    model_id="arn:aws:bedrock:eu-central-1:000000000000:application-inference-profile/a0a0a0a0a0a0",
)

print(response)

Boto3 - Authentifizierung​

Anmeldedaten als Parameter übergeben - Completion()​

AWS-Anmeldedaten als Parameter an litellm.completion übergeben

import os
from litellm import completion

response = completion(
            model="bedrock/anthropic.claude-instant-v1",
            messages=[{ "content": "Hello, how are you?","role": "user"}],
            aws_access_key_id="",
            aws_secret_access_key="",
            aws_region_name="",
)

Zusätzliche Header und benutzerdefinierte API-Endpunkte übergeben​

Dies kann verwendet werden, um bestehende Header (z. B. Authorization) zu überschreiben, wenn benutzerdefinierte API-Endpunkte aufgerufen werden

import os
import litellm
from litellm import completion

litellm.set_verbose = True # 👈 SEE RAW REQUEST

response = completion(
            model="bedrock/anthropic.claude-instant-v1",
            messages=[{ "content": "Hello, how are you?","role": "user"}],
            aws_access_key_id="",
            aws_secret_access_key="",
            aws_region_name="",
            aws_bedrock_runtime_endpoint="https://my-fake-endpoint.com",
            extra_headers={"key": "value"}
)

SSO-Login (AWS-Profil)​

  • Umgebungsvariable AWS_PROFILE festlegen
  • Bedrock-Abschlussaufruf tätigen
import os
from litellm import completion

response = completion(
            model="bedrock/anthropic.claude-instant-v1",
            messages=[{ "content": "Hello, how are you?","role": "user"}]
)

oder aws_profile_name übergeben

import os
from litellm import completion

response = completion(
            model="bedrock/anthropic.claude-instant-v1",
            messages=[{ "content": "Hello, how are you?","role": "user"}],
            aws_profile_name="dev-profile",
)

STS (Rollenbasierte Authentifizierung)​

  • aws_role_name und aws_session_name festlegen
LiteLLM-ParameterBoto3-ParameterBeschreibungBoto3-Dokumentation
aws_access_key_idaws_access_key_idAWS-Zugriffsschlüssel, der einem IAM-Benutzer oder einer Rolle zugeordnet istAnmeldedaten
aws_secret_access_keyaws_secret_access_keyAWS-Geheimschlüssel, der dem Zugriffsschlüssel zugeordnet istAnmeldedaten
aws_role_nameRoleArnDer Amazon Resource Name (ARN) der anzunehmenden RolleAssumeRole API
aws_session_nameRoleSessionNameEin Bezeichner für die angenommene RollensitzungAssumeRole API

Den Bedrock-Abschlussaufruf tätigen

from litellm import completion

response = completion(
            model="bedrock/anthropic.claude-instant-v1",
            messages=messages,
            max_tokens=10,
            temperature=0.1,
            aws_role_name=aws_role_name,
            aws_session_name="my-test-session",
        )

Wenn Sie auch dynamisch den AWS-Benutzer festlegen müssen, der auf die Rolle zugreift, fügen Sie die zusätzlichen Argumente in der completion()/embedding()-Funktion hinzu

from litellm import completion

response = completion(
            model="bedrock/anthropic.claude-instant-v1",
            messages=messages,
            max_tokens=10,
            temperature=0.1,
            aws_region_name=aws_region_name,
            aws_access_key_id=aws_access_key_id,
            aws_secret_access_key=aws_secret_access_key,
            aws_role_name=aws_role_name,
            aws_session_name="my-test-session",
        )

Text zu Bild

curl -L -X POST 'http://0.0.0.0:4000/v1/images/generations' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer $LITELLM_VIRTUAL_KEY' \
-d '{
    "model": "amazon.nova-canvas-v1:0",
    "prompt": "A cute baby sea otter"
}'

Farbgesteuerte Generierung

curl -L -X POST 'http://0.0.0.0:4000/v1/images/generations' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer $LITELLM_VIRTUAL_KEY' \
-d '{
    "model": "amazon.nova-canvas-v1:0",
    "prompt": "A cute baby sea otter",
    "taskType": "COLOR_GUIDED_GENERATION",
    "colorGuidedGenerationParams":{"colors":["#FFFFFF"]}
}'
ModellnameFunktionsaufruf
Stable Diffusion 3 - v0image_generation(model="bedrock/stability.stability.sd3-large-v1:0", prompt=prompt)
Stable Diffusion - v0image_generation(model="bedrock/stability.stable-diffusion-xl-v0", prompt=prompt)
Stable Diffusion - v1image_generation(model="bedrock/stability.stable-diffusion-xl-v1", prompt=prompt)
Amazon Nova Canvas - v0image_generation(model="bedrock/amazon.nova-canvas-v1:0", prompt=prompt)

Übergabe eines externen BedrockRuntime.Client als Parameter - Completion()​

Dies ist ein veralteter Workflow. Boto3 ist nicht asynchron. Und boto3.client lässt uns den HTTP-Aufruf nicht über httpx durchführen. Übergeben Sie Ihre AWS-Parameter über die obige Methode 👆. Authentifizierungscode anzeigen Neuen Authentifizierungsfluss hinzufügen

Danger

Experimentell - 23.06.2024: aws_access_key_id, aws_secret_access_key und aws_session_token werden aus boto3.client extrahiert und an den httpx client übergeben

Übergeben Sie ein externes BedrockRuntime.Client-Objekt als Parameter an litellm.completion. Nützlich bei der Verwendung eines AWS-Anmeldeinformationsprofils, einer SSO-Sitzung, einer angenommenen Rollensitzung oder wenn Umgebungsvariablen für die Authentifizierung nicht verfügbar sind.

Client aus Sitzungsanmeldeinformationen erstellen

import boto3
from litellm import completion

bedrock = boto3.client(
            service_name="bedrock-runtime",
            region_name="us-east-1",
            aws_access_key_id="",
            aws_secret_access_key="",
            aws_session_token="",
)

response = completion(
            model="bedrock/anthropic.claude-instant-v1",
            messages=[{ "content": "Hello, how are you?","role": "user"}],
            aws_bedrock_client=bedrock,
)

Client aus AWS-Profil in ~/.aws/config erstellen

import boto3
from litellm import completion

dev_session = boto3.Session(profile_name="dev-profile")
bedrock = dev_session.client(
            service_name="bedrock-runtime",
            region_name="us-east-1",
)

response = completion(
            model="bedrock/anthropic.claude-instant-v1",
            messages=[{ "content": "Hello, how are you?","role": "user"}],
            aws_bedrock_client=bedrock,
)

Aufruf über internen Proxy (nicht Bedrock-URL-kompatibel)​

Verwenden Sie den Endpunkt bedrock/converse_like/model, um ein Bedrock-Converse-Modell über Ihren internen Proxy aufzurufen.

from litellm import completion

response = completion(
    model="bedrock/converse_like/some-model",
    messages=[{"role": "user", "content": "What's AWS?"}],
    api_key="sk-1234",
    api_base="https://some-api-url/models",
    extra_headers={"test": "hello world"},
)

Erwartete Ausgabeb-URL

https://some-api-url/models