inference configurations are invalid forBedrockEmbeddings models 
Labels: name: area: embeddings, name: area: doc loader, name: area: vector store, name: auto:bug

### System Info

in sagemaker.
langchain==0.0.256 or 0.0.249 (I tried both)
Image: Data Science 3.0
Kernel: Python 3
Instance type: ml.t3.medium 2 vCPU + 4 GiB

### Who can help?

_No response_

### Information

- [X] The official example notebooks/scripts
- [X] My own modified scripts

### Related Components

- [ ] LLMs/Chat Models
- [X] Embedding Models
- [ ] Prompts / Prompt Templates / Prompt Selectors
- [ ] Output Parsers
- [ ] Document Loaders
- [ ] Vector Stores / Retrievers
- [ ] Memory
- [ ] Agents / Agent Executors
- [ ] Tools / Toolkits
- [ ] Chains
- [ ] Callbacks/Tracing
- [ ] Async

### Reproduction

https://github.com/aws-samples/amazon-bedrock-workshop/blob/main/03_QuestionAnswering/01_qa_w_rag_claude.ipynb
im trying to following this notebook:

i increase the data input size:
from urllib.request import urlretrieve

```
os.makedirs("data", exist_ok=True)
files = [
    "https://www.irs.gov/pub/irs-pdf/p1544.pdf",
    "https://www.irs.gov/pub/irs-pdf/p15.pdf",
    "https://www.irs.gov/pub/irs-pdf/p1212.pdf",
    "https://www.irs.gov/pub/irs-pdf/p3.pdf",
    "https://www.irs.gov/pub/irs-pdf/p17.pdf",
    "https://www.irs.gov/pub/irs-pdf/p51.pdf",
    "https://www.irs.gov/pub/irs-pdf/p54.pdf",
]
for url in files:
    file_path = os.path.join("data", url.rpartition("/")[2])
    urlretrieve(url, file_path)

```

my data input:
Average length among 1012 documents loaded is 2320 characters.
After the split we have 1167 documents more than the original 1012.
Average length among 1167 documents (after split) is 2011 characters.

```
import numpy as np
from langchain.text_splitter import CharacterTextSplitter, RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader, PyPDFDirectoryLoader

loader = PyPDFDirectoryLoader("./data/")

documents = loader.load()
# - in our testing Character split works better with this PDF data set
text_splitter = RecursiveCharacterTextSplitter(
    # Set a really small chunk size, just to show.
    chunk_size = 1000,
    chunk_overlap  = 100,
)
docs = text_splitter.split_documents(documents)

avg_doc_length = lambda documents: sum([len(doc.page_content) for doc in documents])//len(documents)
avg_char_count_pre = avg_doc_length(documents)
avg_char_count_post = avg_doc_length(docs)
print(f'Average length among {len(documents)} documents loaded is {avg_char_count_pre} characters.')
print(f'After the split we have {len(docs)} documents more than the original {len(documents)}.')
print(f'Average length among {len(docs)} documents (after split) is {avg_char_count_post} characters.')

from langchain.chains.question_answering import load_qa_chain
from langchain.vectorstores import FAISS
from langchain.indexes import VectorstoreIndexCreator
from langchain.indexes.vectorstore import VectorStoreIndexWrapper

vectorstore_faiss = FAISS.from_documents(
    docs,
    bedrock_embeddings,
)

wrapper_store_faiss = VectorStoreIndexWrapper(vectorstore=vectorstore_faiss)

```

funny thing is if my doc is smaller(docs[:5]), it worked.
vectorstore_faiss = FAISS.from_documents(
**docs[:5]**,
bedrock_embeddings,
)

error:

---------------------------------------------------------------------------
ValidationException                       Traceback (most recent call last)
File /opt/conda/lib/python3.10/site-packages/langchain/embeddings/bedrock.py:120, in BedrockEmbeddings._embedding_func(self, text)
    119 try:
--> 120     response = self.client.invoke_model(
    121         body=body,
    122         modelId=self.model_id,
    123         accept="application/json",
    124         contentType="application/json",
    125     )
    126     response_body = json.loads(response.get("body").read())

File /opt/conda/lib/python3.10/site-packages/botocore/client.py:535, in ClientCreator._create_api_method.<locals>._api_call(self, *args, **kwargs)
    534 # The "self" in this scope is referring to the BaseClient.
--> 535 return self._make_api_call(operation_name, kwargs)

File /opt/conda/lib/python3.10/site-packages/botocore/client.py:980, in BaseClient._make_api_call(self, operation_name, api_params)
    979     error_class = self.exceptions.from_code(error_code)
--> 980     raise error_class(parsed_response, operation_name)
    981 else:

ValidationException: An error occurred (ValidationException) when calling the InvokeModel operation: The provided inference configurations are invalid

During handling of the above exception, another exception occurred:

ValueError                                Traceback (most recent call last)
Cell In[35], line 10
      4 from langchain.indexes.vectorstore import VectorStoreIndexWrapper
      6 
      7 
      8 # 
      9 #
---> 10 vectorstore_faiss = FAISS.from_documents(
     11     docs,
     12     bedrock_embeddings,
     13 )
     15 wrapper_store_faiss = VectorStoreIndexWrapper(vectorstore=vectorstore_faiss)

File /opt/conda/lib/python3.10/site-packages/langchain/vectorstores/base.py:420, in VectorStore.from_documents(cls, documents, embedding, **kwargs)
    418 texts = [d.page_content for d in documents]
    419 metadatas = [d.metadata for d in documents]
--> 420 return cls.from_texts(texts, embedding, metadatas=metadatas, **kwargs)

File /opt/conda/lib/python3.10/site-packages/langchain/vectorstores/faiss.py:607, in FAISS.from_texts(cls, texts, embedding, metadatas, ids, **kwargs)
    581 @classmethod
    582 def from_texts(
    583     cls,
   (...)
    588     **kwargs: Any,
    589 ) -> FAISS:
    590     """Construct FAISS wrapper from raw documents.
    591 
    592     This is a user friendly interface that:
   (...)
    605             faiss = FAISS.from_texts(texts, embeddings)
    606     """
--> 607     embeddings = embedding.embed_documents(texts)
    608     return cls.__from(
    609         texts,
    610         embeddings,
   (...)
    614         **kwargs,
    615     )

File /opt/conda/lib/python3.10/site-packages/langchain/embeddings/bedrock.py:148, in BedrockEmbeddings.embed_documents(self, texts, chunk_size)
    146 results = []
    147 for text in texts:
--> 148     response = self._embedding_func(text)
    149     results.append(response)
    150 return results

File /opt/conda/lib/python3.10/site-packages/langchain/embeddings/bedrock.py:129, in BedrockEmbeddings._embedding_func(self, text)
    127     return response_body.get("embedding")
    128 except Exception as e:
--> 129     raise ValueError(f"Error raised by inference endpoint: {e}")

ValueError: Error raised by inference endpoint: An error occurred (ValidationException) when calling the InvokeModel operation: The provided inference configurations are invalid




### Expected behavior

I would like to generate embeddings for the entire corpus and stored in a vector store.