Mistral Massive 2 now accessible on Amazon Bedrock

$ aws bedrock-runtime invoke-model  
--model-id mistral.mistral-large-2407-v1:0 
--body "{"immediate":"<s>[INST] that is the place you place your enter textual content [/INST]", "max_tokens":200, "temperature":0.5, "top_p":0.9, "top_k":50}"  
--cli-binary-format raw-in-base64-out 
--region us-west-2  
invoke-model-output.txt

# Outline the device configuration
import json
tool_list = [
    {
        "toolSpec": {
            "name": "travel_agent",
            "description": "Converts trip details as a json structure.",
            "inputSchema": {
                "json": {
                    "type": "object",
                    "properties": {
                        "origin_airport": {
                            "type": "string",
                            "description": "Origin airport (IATA code)"
                        },
                        "destination_airport": {
                            "type": "boolean",
                            "description": "Destination airport (IATA code)"
                        },
                        "departure_date": {
                            "type": "string",
                            "description": "Departure date",
                        }, 
                        "return_date": {
                            "type": "string",
                            "description": "Return date",
                        }
                    },
                    "required": [
                        "origin_airport",
                        "destination_airport",
                        "departure_date",
                        "return_date"
                    ]
                }
            }
        }
    }
]
content material = """
I wish to ebook a flight from New York (JFK) to London (LHR) for a round-trip.
The departure date is June 15, 2023, and the return date is June 25, 2023.

For the flight preferences, I would like to fly with Delta or United Airways. 
My most popular departure time vary is between 8 AM and 11 AM, and my most popular arrival time vary is between 9 AM and 1 PM (native time in London). 
I'm open to flights with one cease, however not more than that.
Please embrace continuous flight choices if accessible.
"""

message = {
    "position": "person",
    "content material": [
        { "text": f"<content>{content}</content>" },
        { "text": "Please create a well-structured JSON object representing the flight booking request, ensuring proper nesting and organization of the data. Include sample data for better understanding. Create the JSON based on the content within the <content> tags." }
    ],
}
# Bedrock consumer configuration
response = bedrock_client.converse(
    modelId=model_id,
    messages=[message],
    inferenceConfig={
        "maxTokens": 500,
        "temperature": 0.1
    },
    toolConfig={
        "instruments": tool_list
    }
)

response_message = response['output']['message']
response_content_blocks = response_message['content']
content_block = subsequent((block for block in response_content_blocks if 'toolUse' in block), None)
tool_use_block = content_block['toolUse']
tool_result_dict = tool_use_block['input']

print(json.dumps(tool_result_dict, indent=4))

{
    "origin_airport": "JFK",
    "destination_airport": "LHR",
    "departure_date": "2023-06-15",
    "return_date": "2023-06-25"
}

# Outline the device configuration
toolConfig = {
    "instruments": [
        {
            "toolSpec": {
                "name": "shinkansen_schedule",
                "description": "Fetches Shinkansen train schedule departure times for a specified station and time.",
                "inputSchema": {
                    "json": {
                        "type": "object",
                        "properties": {
                            "station": {
                                "type": "string",
                                "description": "The station name."
                            },
                            "departure_time": {
                                "type": "string",
                                "description": "The departure time in HH:MM format."
                            }
                        },
                        "required": ["station", "departure_time"]
                    }
                }
            }
        }
    ]
}
# Outline shikansen schedule device
def shinkansen_schedule(station, departure_time):
    schedule = {
        "Tokyo": {"09:00": "Hikari", "12:00": "Nozomi", "15:00": "Kodama"},
        "Osaka": {"10:00": "Nozomi", "13:00": "Hikari", "16:00": "Kodama"}
    }
    return schedule.get(station, {}).get(departure_time, "No prepare discovered")
def prompt_mistral(immediate):
    messages = [{"role": "user", "content": [{"text": prompt}]}]
    converse_api_params = {
        "modelId": model_id,
        "messages": messages,
        "toolConfig": toolConfig,  
        "inferenceConfig": {"temperature": 0.0, "maxTokens": 400},
    }

    response = bedrock_client.converse(**converse_api_params)
    
    if response['output']['message']['content'][0].get('toolUse'):
        tool_use = response['output']['message']['content'][0]['toolUse']
        tool_name = tool_use['name']
        tool_inputs = tool_use['input']

        if tool_name == "shinkansen_schedule":
            print("Mistral needs to make use of the shinkansen_schedule device")
            station = tool_inputs["station"]
            departure_time = tool_inputs["departure_time"]
            
            strive:
                consequence = shinkansen_schedule(station, departure_time)
                print("Prepare schedule consequence:", consequence)
            besides ValueError as e:
                print(f"Error: {str(e)}")

    else:
        print("Mistral responded with:")
        print(response['output']['message']['content'][0]['text'])
prompt_mistral("What prepare departs Tokyo at 9:00?")

Mistral needs to make use of the shinkansen_schedule device
Prepare schedule consequence: Hikari

emails= """
"I not too long ago purchased your RGB gaming keyboard and completely love the customizable lighting options! Are you able to information me on the right way to arrange totally different profiles for every recreation I play?"
"I am making an attempt to make use of the macro keys on the gaming keyboard I simply bought, however they aren't registering my inputs. May you assist me work out what is likely to be going fallacious?"
"I am contemplating shopping for your gaming keyboard and I am inquisitive about the important thing swap sorts. What choices can be found and what are their primary variations?"
"I wished to report a small subject the place my keyboard's house bar is a bit squeaky. Nonetheless, your quick-start information was tremendous useful and I mounted it simply by following the lubrication suggestions. Simply thought you would possibly need to know!"
"My new gaming keyboard stopped working inside per week of buy. Not one of the keys reply, and the lights do not activate. I would like an answer or a substitute as quickly as potential."
"I've observed that the letters on the keys of my gaming keyboard are beginning to fade after a number of months of use. Is that this lined by the guarantee?"
"I had a problem the place my keyboard settings would reset each time I restarted my PC. I found out it was attributable to a software program battle and resolved it by updating the firmware. Simply wished to ask if there are any new updates coming quickly?"
"I have been having bother with the keyboard software program not saving my configurations, and it is beginning to get irritating. What may be completed to make sure my settings are saved completely?"
"""
def converse(immediate, inference_config):
    messages = [{"role": "user", "content": [{"text": prompt}]}]
    response = bedrock_client.converse(
        messages=messages,
        modelId=model_id,
        inferenceConfig=inference_config
    )
    generated_text = response['output']['message']['content'][0]['text']
    print(generated_text)
    return generated_text

immediate=f"""

emails={emails}

Translate the next buyer emails into these languages:

1. Hindi
2. Japanese

Label every language part accordingly""".format(emails=emails)

inference_config = {"temperature": 0.0, "maxTokens": 4000, "topP": 0.1}

response = converse(immediate, inference_config) 

1. "मैंने हाल ही में आपका RGB गेमिंग कीबोर्ड खरीदा और कस्टमाइजेबल लाइटिंग फीचर्स से बहुत प्रेम करता हूँ! क्या आप मुझे बता सकते हैं कि मैं हर गेम के लिए अलग-अलग प्रोफाइल कैसे सेट कर सकता हूँ?"
2. "मैं अपने नए गेमिंग कीबोर्ड पर मैक्रो कीज का उपयोग करने की कोशिश कर रहा हूँ, लेकिन वे मेरे इनपुट्स को रजिस्टर नहीं कर रहे हैं। क्या आप मुझे बता सकते हैं कि क्या गलत हो सकता है?"
3. "मैं आपका गेमिंग कीबोर्ड खरीदने के बारे में सोच रहा हूँ और मुझे की स्विच टाइप्स के बारे में जानना है। क्या विकल्प उपलब्ध हैं और उनके मुख्य अंतर क्या हैं?"
4. "मैं यह रिपोर्ट करना चाहता था कि मेरे कीबोर्ड का स्पेस बार थोड़ा सा चरमरा रहा है। हालाँकि, आपका क्विक-स्टार्ट गाइड बहुत मददगार था और मैंने लुब्रिकेशन टिप्स का पालन करके इसे आसानी से ठीक कर दिया। बस यह जानना चाहता था कि शायद आपको पता चलना चाहिए!"
5. "मेरा नया गेमिंग कीबोर्ड खरीद के एक सप्ताह के भीतर काम करना बंद हो गया। कोई भी की जवाब नहीं दे रहा है, और लाइट्स भी नहीं चालू हो रहे हैं। मुझे एक समाधान या एक रिप्लेसमेंट जितनी जल्दी हो सके चाहिए।"
6. "मैंने नोट किया है कि मेरे गेमिंग कीबोर्ड के कीज पर अक्षर कुछ महीनों के उपयोग के बाद फेड होने लगे हैं। क्या यह वारंटी के तहत कवर है?"
7. "मेरे कीबोर्ड सेटिंग्स हर बार मेरे पीसी को रीस्टार्ट करने पर रीसेट हो जाती थीं। मैंने पता लगाया कि यह एक सॉफ्टवेयर कॉन्फ्लिक्ट के कारण था और फर्मवेयर अपडेट करके इसे सुलझा दिया। बस पूछना चाहता था कि क्या कोई नए अपडेट आने वाले हैं?"
8. "मेरे कीबोर्ड सॉफ्टवेयर मेरी कॉन्फ़िगरेशन को सेव नहीं कर रहे हैं, और यह अब परेशान करने लगा है। मेरे सेटिंग्स को स्थायी रूप से सेव करने के लिए क्या किया जा सकता है?"

### Japanese

1. "最近、あなたのRGBゲーミングキーボードを購入し、カスタマイズ可能なライティング機能が大好きです！ 各ゲームごとに異なるプロファイルを設定する方法を教えていただけますか？"
2. "新しく購入したゲーミングキーボードのマクロキーを使おうとしていますが、入力が認識されません。何が問題か教えていただけますか？"
3. "あなたのゲーミングキーボードを購入しようと考えていますが、キースイッチの種類について知りたいです。どのようなオプションがあり、その主な違いは何ですか？"
4. "キーボードのスペースバーが少しきしむようになりました。ただし、クイックスタートガイドが非常に役立ち、潤滑のヒントに従って簡単に修理できました。ただ、知っておいてほしいと思いました！"
5. "新しいゲーミングキーボードが購入後1週間で動作しなくなりました。どのキーも反応せず、ライトも点きません。できるだけ早く解決策や交換をお願いします。"
6. "ゲーミングキーボードのキーの文字が数ヶ月の使用後に消え始めました。これは保証に含まれますか？"
7. "キーボードの設定がPCを再起動するたびにリセットされていました。ソフトウェアの競合が原因であることがわかり、ファームウェアを更新して解決しました。新しいアップデートが近々来るのか教えていただけますか？"
8. "キーボードソフトウェアが設定を保存しないため、非常に困っています。設定を永続的に保存するために何ができますか？"

immediate = """
Write a Python perform referred to as palindrome_prime_finder that finds all prime numbers inside a given vary which can be additionally palindromes when written in base 10 (decimal system).
"""

inference_config = {"temperature": 0.0, "maxTokens": 1000, "topP": 0.1}

response = converse(immediate, inference_config)

Definitely! Beneath is a Python perform referred to as `palindrome_prime_finder` that finds all prime numbers inside a given vary which can be additionally palindromes when written in base 10.

```python
def is_prime(n):
    """Test if a quantity is prime."""
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    whereas i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True

def is_palindrome(n):
    """Test if a quantity is a palindrome."""
    return str(n) == str(n)[::-1]

def palindrome_prime_finder(begin, finish):
    """Discover all prime numbers inside a given vary which can be additionally palindromes."""
    palindrome_primes = []
    for num in vary(begin, finish + 1):
        if is_prime(num) and is_palindrome(num):
            palindrome_primes.append(num)
    return palindrome_primes

# Instance utilization:
start_range = 1
end_range = 1000
print(palindrome_prime_finder(start_range, end_range))
```

### Rationalization:
1. **is_prime(n)**: This perform checks if a quantity `n` is prime. It makes use of a fundamental primality take a look at that eliminates even numbers and numbers divisible by 3 early, then checks divisibility as much as the sq. root of `n`.

2. **is_palindrome(n)**: This perform checks if a quantity `n` is a palindrome by changing it to a string and evaluating it to its reverse.

3. **palindrome_prime_finder(begin, finish)**: This perform iterates by all numbers within the given vary `[start, end]`. For every quantity, it checks whether it is each a major and a palindrome. If each circumstances are met, the quantity is added to the record `palindrome_primes`.

### Instance Utilization:
The instance utilization finds all palindromic prime numbers between 1 and 1000. You'll be able to alter the `start_range` and `end_range` variables to seek out palindromic primes in any desired vary.