import boto3
 
# Spécifier le service utilisé.
dynamodb = boto3.resource("dynamodb")
 
# Création de la table nommée "SessionTable" avec l'attribut "SessionId".
table = dynamodb.create_table(
    TableName="SessionTable",
    KeySchema=[{"AttributeName": "SessionId", "KeyType": "HASH"}],
    AttributeDefinitions=[{"AttributeName": "SessionId", "AttributeType": "S"}],
    BillingMode="PAY_PER_REQUEST",
    )
   
# Mise en attente durant la création de la table.
table.wait_until_exists()
 
# Affichage du nombre d'éléments de la table après sa création.
print(table.item_count)
 
Le code du chatbot ci-dessous implémente les composant initiaux de notre application.
# Import des bibliothèques Streamlit, Langchain et de la fonction précédente
import streamlit as st
from langchain.llms import Bedrock
from langchain.memory.chat_message_histories import DynamoDBChatMessageHistory
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
from langchain.prompts.prompt import PromptTemplate
from langchain.memory.chat_message_histories import StreamlitChatMessageHistory
import uuid
 
# Définition du prompte par défaut pour l'initialisation du chatbot
DEFAULT_CLAUDE_TEMPLATE = """The following is a friendly conversation between a
human and an AI. The AI is talkative and provides lots of specific details from its
context. If the AI does not know the answer to a question, it truthfully says it
does not know.
 
Current conversation:
{history}
Human: {input}
Assistant:"""
 
# Définition de la structure du prompte (étape 3 du diagramme d'architecture figure 1)
CLAUDE_PROMPT = PromptTemplate(
    input_variables=["history", "input"],  template=DEFAULT_CLAUDE_TEMPLATE)
 
# Message d'initiation de la discussion avec le chatbot
INIT_MESSAGE = {"role": "assistant", "content": "Comment puis-je vous aider ? "}
 
# Composants de l'interface graphique
st.set_page_config(page_title='Chatbot', layout='wide')
st.title("Bonjour, je suis votre chatbot.")
 
# Fonction récupération d'un identifiant pour la session de discussion pour créer un enregistrement sur la base de données DynamoDB
@st.cache_data
def id_sess():
    id = str(uuid.uuid4())
    return id
session_id=id_sess()
 
# Fonction de création de la chaine de conversation Langchain
def init_conversationchain():
    # Définition du modèle appelé via l'API Bedrock et de ses paramètres par défaut
    model_kwargs = {'temperature': 0.5,
                    'top_p': 1,
                    'top_k': 250,
                    'max_tokens_to_sample': 500
                    }
    llm = Bedrock( model_id="anthropic.claude-v2:1", model_kwargs=model_kwargs )
   
    # Définition de la base de données DynamoDB créée précédemment comme mémoire pour l'historique de conversation
    message_history = DynamoDBChatMessageHistory(
        table_name="SessionTable", session_id=session_id
    )
   
    # Création de la chaine de conversation
    conversation = ConversationChain(
        llm=llm,
        verbose=True,
        memory=ConversationBufferMemory(
            ai_prefix="Assistant", chat_memory=message_history,
            return_messages=True),
        prompt=CLAUDE_PROMPT
    )
 
    # Initialisation du chatbot avec l'INIT_MESSAGE
    if "messages" not in st.session_state.keys():
        st.session_state.messages = [INIT_MESSAGE]
 
    return conversation
 
# Fonction utilisée pour générer les réponses du chatbot
def generate_response(conversation, input_text):
    return conversation.run(input=input_text)
 
# Fonction d'initialisation d'un nouveau chat
def new_chat(session_id):
    st.session_state["messages"] = [INIT_MESSAGE]
    st.session_state["langchain_messages"] = []
    conv_chain = init_conversationchain()
 
# Ajout d'un bouton à l'interface graphique pour faire appel à la fonction de réinitialisation du chat
st.sidebar.button("New Chat", on_click=new_chat(session_id), type='primary')
 
# Initialisation du chatbot
conv_chain = init_conversationchain()
 
# Affichage des messages de la discussion sur l'interface graphique
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])
 
# Prompte entré par l'utilisateur du chatbot
prompt = st.chat_input()
if prompt:
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)
 
# Générer une réponse si le dernier message ne provient pas du chatbot
if st.session_state.messages[-1]["role"] != "assistant":
    with st.chat_message("assistant"):
        with st.spinner("Thinking..."):
            response = generate_response(conv_chain, prompt)
            st.markdown(response)
    message = {"role": "assistant", "content": response}
    st.session_state.messages.append(message)