synaptic-bedrock 0.4.0

AWS Bedrock integration for Synaptic: ChatModel via Converse API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use synaptic_bedrock::{BedrockChatModel, BedrockConfig};
use synaptic_core::{ChatModel, ChatRequest, Message};

#[test]
fn config_builder_defaults() {
    let config = BedrockConfig::new("anthropic.claude-3-5-sonnet-20241022-v2:0");
    assert_eq!(config.model_id, "anthropic.claude-3-5-sonnet-20241022-v2:0");
    assert!(config.region.is_none());
    assert!(config.max_tokens.is_none());
    assert!(config.temperature.is_none());
    assert!(config.top_p.is_none());
    assert!(config.stop.is_none());
}

#[test]
fn config_builder_all_fields() {
    let config = BedrockConfig::new("anthropic.claude-3-5-sonnet-20241022-v2:0")
        .with_region("us-west-2")
        .with_max_tokens(1000)
        .with_temperature(0.7)
        .with_top_p(0.9)
        .with_stop(vec!["END".to_string()]);

    assert_eq!(config.model_id, "anthropic.claude-3-5-sonnet-20241022-v2:0");
    assert_eq!(config.region, Some("us-west-2".to_string()));
    assert_eq!(config.max_tokens, Some(1000));
    assert_eq!(config.temperature, Some(0.7));
    assert_eq!(config.top_p, Some(0.9));
    assert_eq!(config.stop, Some(vec!["END".to_string()]));
}

#[test]
fn config_builder_chaining() {
    let config = BedrockConfig::new("amazon.titan-text-express-v1")
        .with_region("eu-west-1")
        .with_max_tokens(500);

    assert_eq!(config.model_id, "amazon.titan-text-express-v1");
    assert_eq!(config.region, Some("eu-west-1".to_string()));
    assert_eq!(config.max_tokens, Some(500));
}

#[tokio::test]
#[ignore] // Requires AWS credentials
async fn integration_basic_chat() {
    let config =
        BedrockConfig::new("anthropic.claude-3-5-sonnet-20241022-v2:0").with_max_tokens(100);
    let model = BedrockChatModel::new(config).await;

    let request = ChatRequest::new(vec![
        Message::system("You are a helpful assistant."),
        Message::human("Say hello in exactly one word."),
    ]);

    let response = model.chat(request).await.unwrap();
    assert!(response.message.is_ai());
    assert!(!response.message.content().is_empty());
}

#[tokio::test]
#[ignore] // Requires AWS credentials
async fn integration_streaming() {
    use futures::StreamExt;

    let config =
        BedrockConfig::new("anthropic.claude-3-5-sonnet-20241022-v2:0").with_max_tokens(50);
    let model = BedrockChatModel::new(config).await;

    let request = ChatRequest::new(vec![Message::human("Count from 1 to 5.")]);

    let mut stream = model.stream_chat(request);
    let mut chunks = Vec::new();

    while let Some(result) = stream.next().await {
        let chunk = result.unwrap();
        chunks.push(chunk);
    }

    assert!(!chunks.is_empty());
}

#[tokio::test]
#[ignore] // Requires AWS credentials
async fn integration_tool_calling() {
    use synaptic_core::{ToolChoice, ToolDefinition};

    let config =
        BedrockConfig::new("anthropic.claude-3-5-sonnet-20241022-v2:0").with_max_tokens(200);
    let model = BedrockChatModel::new(config).await;

    let tool = ToolDefinition {
        name: "get_weather".to_string(),
        description: "Get the current weather for a location".to_string(),
        parameters: serde_json::json!({
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "The city name"
                }
            },
            "required": ["city"]
        }),
        extras: None,
    };

    let request = ChatRequest::new(vec![Message::human(
        "What is the weather in San Francisco?",
    )])
    .with_tools(vec![tool])
    .with_tool_choice(ToolChoice::Auto);

    let response = model.chat(request).await.unwrap();
    assert!(response.message.is_ai());
    // The model should call the tool.
    assert!(!response.message.tool_calls().is_empty());
    assert_eq!(response.message.tool_calls()[0].name, "get_weather");
}