value is not a valid dict (type=type_error.dict)
Labels: name: auto:bug, name: auto:question, name: area: models

### Issue you'd like to raise.

when i try and run this script 

```
class WebsiteSummary:
    def _SummorizeWebsite(objective, websiteContent):
        my_gpt_instance = MyGPT4ALL()
       
        textSplitter = RecursiveCharacterTextSplitter(
            separators=["\n\n", "\n"], chunk_size=10000, chunk_overlap=500
        )

        docs = textSplitter.create_documents([websiteContent])
        print(docs)
        mapPrompt = """"
        write a summary of the following {objective}: 
        {text}
        SUMMARY: 
        """
        map_prompt_template = PromptTemplate(
            template=mapPrompt, input_variables=["text", "objective"]
        ) 
        chain = load_summarize_chain(llm=my_gpt_instance,
                                     chain_type="map_reduce",                                     
                                     verbose=True,
                                     map_prompt=objective,
                                     combine_prompt=map_prompt_template)

        output = summary_Chain.run(input_documents=docs, objective=objective)
        return output
```

i get this issue 
Exception has occurred: ValidationError
1 validation error for LLMChain
prompt
  value is not a valid dict (type=type_error.dict)
  File "E:\StormboxBrain\langchain\websiteSummary.py", line 27, in _SummorizeWebsite
    chain = load_summarize_chain(llm=my_gpt_instance,
  File "E:\StormboxBrain\langchain\app.py", line 12, in <module>
    summary = websiteSummary._SummorizeWebsite(objective, data)
pydantic.error_wrappers.ValidationError: 1 validation error for LLMChain

my model does load and can create prompt responses 
mistral-7b-openorca.Q4_0.gguf



this is mygpt4all class 
```
import os
from pydantic import Field
from typing import List, Mapping, Optional, Any
from langchain.llms.base import LLM
from gpt4all import GPT4All, pyllmodel


class MyGPT4ALL(LLM):
    """
    A custom LLM class that integrates gpt4all models

    Arguments:

    model_folder_path: (str) Folder path where the model lies
    model_name: (str) The name of the model to use (<model name>.gguf)

    backend: (str) The backend of the model (Supported backends: llama/gptj)
    n_threads: (str) The number of threads to use
    n_predict: (str) The maximum numbers of tokens to generate
    temp: (str) Temperature to use for sampling
    top_p: (float) The top-p value to use for sampling
    top_k: (float) The top k values use for sampling
    n_batch: (int) Batch size for prompt processing
    repeat_last_n: (int) Last n number of tokens to penalize
    repeat_penalty: (float) The penalty to apply repeated tokens

    """

    model_folder_path: str = "./models/"
    model_name: str = "mistral-7b-openorca.Q4_0.gguf"

    backend: Optional[str] = "llama"
    temp: Optional[float] = 0.7
    top_p: Optional[float] = 0.1
    top_k: Optional[int] = 40
    n_batch: Optional[int] = 8
    n_threads: Optional[int] = 4
    n_predict: Optional[int] = 256
    max_tokens: Optional[int] = 200
    repeat_last_n: Optional[int] = 64
    repeat_penalty: Optional[float] = 1.18

    # initialize the model
    gpt4_model_instance: Any = None

    def __init__(self, **kwargs):
        super(MyGPT4ALL, self).__init__()
        print("init " + self.model_folder_path + self.model_name)
        self.gpt4_model_instance = GPT4All(
            model_name=self.model_name,
            model_path=self.model_folder_path,
            device="cpu",
            verbose=True,
        )
        print("initiolized " + self.model_folder_path + self.model_name)

    @property
    def _get_model_default_parameters(self):
        print("get default params")
        return {
            "max_tokens": self.max_tokens,
            "n_predict": self.n_predict,
            "top_k": self.top_k,
            "top_p": self.top_p,
            "temp": self.temp,
            "n_batch": self.n_batch,
            "repeat_penalty": self.repeat_penalty,
            "repeat_last_n": self.repeat_last_n,
        }

    @property
    def _identifying_params(self) -> Mapping[str, Any]:
        print(" Get all the identifying parameters")
        return {
            "model_name": self.model_name,
            "model_path": self.model_folder_path,
            "model_parameters": self._get_model_default_parameters,
        }

    @property
    def _llm_type(self) -> str:
        return "llama"

    def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs) -> str:
        """
        Args:
            prompt: The prompt to pass into the model.
            stop: A list of strings to stop generation when encountered

        Returns:
            The string generated by the model
        """

        params = {**self._get_model_default_parameters, **kwargs}
        print("params:")
        for key, value in params.items():
            print(f"{key}: {value}")
        print("params " + params.values())
        return "initiolized"

```

### Suggestion:

is there any documentation on how to use another llm as base and not gpt