Issue: Chain call methods are confusing (LLMChain vs SimpleSequentialChain)
Labels: name: area: doc loader, name: auto:bug

### Issue you'd like to raise.

According to [here](https://python.langchain.com/docs/modules/chains/how_to/call_methods), all subclass inherited from the Chain class will have the `__call__()` and the `run()` methods to launch the chain. And according to the [LLMChain API](https://api.python.langchain.com/en/latest/chains/langchain.chains.llm.LLMChain.html?highlight=llmchain#langchain.chains.llm.LLMChain) and [SimpleSequentialChain API](https://api.python.langchain.com/en/latest/chains/langchain.chains.sequential.SimpleSequentialChain.html#langchain.chains.sequential.SimpleSequentialChain), both of them are inherited from the Chain class. However I found LLMChain and SimpleSequentialChain accept different kinds of input patterns when calling `__call__()` and the `run()`, which are highly confusing.

To demonstrate, consider the following setup, where we create an LLMChain that runs a prompt template that simply asks the LLM to repeat what is told, and attach the LLMChain to a SimpleSequentialChain:
```
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.prompts import StringPromptTemplate
from pydantic import BaseModel, validator

class CustomTemplate(StringPromptTemplate, BaseModel):
    """A custom prompt template that takes in the path to a json file as input, and formats the prompt template."""

    @validator("input_variables")
    def validate_input_variables(cls, v):
        """Validate that the input variables are correct."""
        if len(v) == 0 or "CustomKwarg" not in v:
            raise ValueError("CustomKwarg keyword argument must be provided .")
        return v

    def format(self, **kwargs) -> str:
        return "Repeat the following: \"" + kwargs["CustomKwarg"] + "\""

llmchain = LLMChain(llm=llm, 
                    prompt=CustomTemplate(input_variables=["CustomKwarg"]),
                    verbose=True)
simplesequentialchain = SimpleSequentialChain(chains=[llmchain])
```
where ``llm`` is a custom llm.

In the prompt template, we expect a keyword argument (kwarg) called `CustomKwarg` to be provided when we launch the chains. There are, however, several ways to provide `CustomKwarg`, e.g. directly providing the value for `CustomKwarg`, or providing a dictionary that maps a key "CustomKwarg" to the value of `CustomKwarg`. Also, sometimes we need to specify `input` or `inputs` as the keyword argument when we make the function call. These lead to many possible combination of syntaxes to launch the chains, and I found that the syntaxes accepted by the LLMChain and SimpleSequentialChain very different and inconsistent. Assuming we want to provide "XYZ!" as the value for CustomKwarg to the chain, see the summary of the launching results below.

|#|command                                                               | `c = llmchain` | `c = simplesequentialchain` |
|-|---------------------------------------------   | -----------| --------------------------|
|1|`c("XYZ!")`| O | O|
|2|`c({"CustomKwarg": "XYZ!"})`| O | `Missing some input keys: {'input'}` |
|3|`c({"input": "XYZ!"})`| `Missing some input keys: {'CustomKwarg'}` | O |
|4| `c({"inputs": "XYZ!"})`| `Missing some input keys: {'CustomKwarg'}`| `Missing some input keys: {'input'}` |
|5|`c(input={"CustomKwarg": "XYZ!"})`| `Chain.__call__() got an unexpected keyword argument 'input'` | `Chain.__call__() got an unexpected keyword argument 'input'` |
|6|`c(inputs={"CustomKwarg": "XYZ!"})`| O | `Missing some input keys: {'input'}` |
|7|`c.run("Hello there!")`| O | O |
|8|`c.run({"CustomKwarg": "XYZ!"})`| O | `Missing some input keys: {'input'}` |
|9|`c.run({"input": "XYZ!"})`| `Missing some input keys: {'CustomKwarg'}` | O |
|10|`c.run({"inputs": "Hello there!"})`| `Missing some input keys: {'CustomKwarg'}` | `Missing some input keys: {'input'}`|
|11|`c.run(input={"CustomKwarg": "XYZ!"})`| `Missing some input keys: {'CustomKwarg'}` | O |
|12|`c.run(inputs={"CustomKwarg": "XYZ!"})`| `Missing some input keys: {'CustomKwarg'}` | `Missing some input keys: {'input'}`|

The allowed syntax patterns are highly inconsistent among the two types of chains. For the same syntax, the two types of chains can even fail on different error messages, which is very confusing. Since both of the chains are subclasses of Chain, one would expect them to behave similarly, especially for those methods inherited from the Chain class (`__call__()` and `run()`).

Note: I am using **LangChain ver. 0.0.225**.

### Suggestion:

_No response_