Constantly encountering issue/error while creating the full-chain while dealing with large database.

[mangeshcodeadda]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from langchain_core.output_parsers.openai_tools import PydanticToolsParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field
from app import mysql, llm
from openai_module import init_openai
from operator import itemgetter

from langchain.chains import create_sql_query_chain
from langchain_core.runnables import RunnablePassthrough



class Table(BaseModel):
    """Table in SQL database."""

    name: str = Field(description="Name of table in SQL database.")


def invoke_table_chain(user_input):
    try:
        table_names = "\n".join(mysql.get_usable_table_names())
        
        system = f"""Return the names of ALL the SQL tables that MIGHT be relevant to the user question. \
        The tables are:
        
        {table_names}
        
        Remember to include ALL POTENTIALLY RELEVANT tables, even if you're not sure that they're needed.
        """

        prompt = ChatPromptTemplate.from_messages(
            [
                ("system", system),
                ("human", f"{user_input}"),
            ]
        )

        llm_with_tools = llm.bind_tools([Table])
        output_parser = PydanticToolsParser(tools=[Table])
        table_chain = prompt | llm_with_tools | output_parser
        table_chain.invoke({"input": f'{user_input}'})
        query_chain = create_sql_query_chain(llm, mysql)
        # Convert "question" key to the "input" key expected by current table_chain.
        table_chain = {"input": itemgetter(f"{user_input}")} | table_chain
        # Set table_names_to_use using table_chain.
        full_chain = RunnablePassthrough.assign(table_names_to_use=table_chain) | query_chain
        print(f"full_chain: \n{full_chain}\n")
        query = full_chain.invoke({"question": f'{user_input}'})
        return query
    except Exception as ex:
        print(f"In invoke_table_chain() => {ex}")
        return None

Description

Im using below pakages of langchin,
langchain 0.2.12
langchain-community 0.2.11
langchain-core 0.2.27
langchain-openai 0.1.20

constantly getting error as "unsupported operand type(s) for |: 'dict' and 'list'" at line "table_chain = {"input": itemgetter(f"{question}")} | table_chain", where table chain output is [Table(name='bmt_app_client'), Table(name='bmt_app_userprofile_client')]

System Info

System Information

OS: Windows
OS Version: 10.0.22631
Python Version: 3.10.0 (tags/v3.10.0:b494f59, Oct 4 2021, 19:00:18) [MSC v.1929 64 bit (AMD64)]

Package Information

langchain_core: 0.2.27
langchain: 0.2.12
langchain_community: 0.2.11
langsmith: 0.1.96
langchain_openai: 0.1.20
langchain_text_splitters: 0.2.2

Packages not installed (Not Necessarily a Problem)

The following packages were not found:

langgraph
langserve

[dosubot[bot]]

@mangeshcodeadda Hello! I'm here to help you with any bugs, questions, or become a contributor.

The error "unsupported operand type(s) for |: 'dict' and 'list'" occurs because the | operator is being used between a dictionary and a list, which is not supported. To resolve this, you need to ensure that the operands of the | operator are compatible types.

In your code, the problematic line is:

table_chain = {"input": itemgetter(f"{user_input}")} | table_chain

Here, {"input": itemgetter(f"{user_input}")} is a dictionary, and table_chain is likely a list or another incompatible type. Instead, you should use appropriate methods to combine these data structures.

To fix this, you can use the merge_dicts function to merge dictionaries, and ensure that table_chain is in the correct format. Here's an example of how you can modify your code:

1. Ensure table_chain is a dictionary or convert it to one if necessary.
2. Use merge_dicts to combine dictionaries.

Here's the updated code snippet:

from langchain_core.utils._merge import merge_dicts

# Ensure table_chain is a dictionary
table_chain_dict = {"input": itemgetter(f"{user_input}")}

# Merge dictionaries
table_chain = merge_dicts(table_chain_dict, table_chain)

# Set table_names_to_use using table_chain.
full_chain = RunnablePassthrough.assign(table_names_to_use=table_chain) | query_chain

This should resolve the error by ensuring that the operands of the | operator are compatible types. If table_chain is not a dictionary, you may need to adjust the code accordingly to ensure compatibility.

Additionally, make sure you are using the correct versions of the LangChain packages, as there might be updates that affect the usage of the | operator or the chaining of components ^[1][2].

To continue talking to Dosu, mention @dosu.

[mangeshcodeadda]

@dosu Thank you for you support,

I tried using your solution. After implementing it, the table chains became:

{'input': operator.itemgetter('Find total number of clients present in database'), 'table_names_to_use': ['bmt_app_client', 'bmt_app_userprofile_client']}

at line ""full_chain = RunnablePassthrough.assign(table_names_to_use=table_chain) | query_chain"""

However, I still encountered an error, albeit a different one:

ERROR: Expected a Runnable, callable, or dict. Instead got an unsupported type: <class 'list'>

Could you help me resolve this issue ?

[dosubot[bot]]

The error "Expected a Runnable, callable, or dict. Instead got an unsupported type: <class 'list'>" indicates that the table_chain is being passed as a list, which is not supported. To resolve this, you need to ensure that table_chain is a Runnable, callable, or dictionary.

Here's how you can modify your code to ensure that table_chain is correctly formatted:

1. Use RunnableParallel to handle multiple runnables.
2. Ensure that table_chain is a dictionary or a Runnable.

Here's the updated code snippet:

from langchain_core.runnables import RunnableParallel, RunnablePassthrough
from operator import itemgetter

def invoke_table_chain(user_input):
    try:
        table_names = "\n".join(mysql.get_usable_table_names())
        
        system = f"""Return the names of ALL the SQL tables that MIGHT be relevant to the user question. \
        The tables are:
        
        {table_names}
        
        Remember to include ALL POTENTIALLY RELEVANT tables, even if you're not sure that they're needed.
        """

        prompt = ChatPromptTemplate.from_messages(
            [
                ("system", system),
                ("human", f"{user_input}"),
            ]
        )

        llm_with_tools = llm.bind_tools([Table])
        output_parser = PydanticToolsParser(tools=[Table])
        table_chain = prompt | llm_with_tools | output_parser
        table_chain_result = table_chain.invoke({"input": f'{user_input}'})
        
        # Convert "question" key to the "input" key expected by current table_chain.
        table_chain_dict = {"input": itemgetter(f"{user_input}")}
        
        # Use RunnableParallel to handle multiple runnables
        table_chain_runnable = RunnableParallel({
            "input": itemgetter(f"{user_input}"),
            "table_names_to_use": table_chain_result
        })
        
        query_chain = create_sql_query_chain(llm, mysql)
        
        # Set table_names_to_use using table_chain_runnable.
        full_chain = RunnablePassthrough.assign(table_names_to_use=table_chain_runnable) | query_chain
        print(f"full_chain: \n{full_chain}\n")
        query = full_chain.invoke({"question": f'{user_input}'})
        return query
    except Exception as ex:
        print(f"In invoke_table_chain() => {ex}")
        return None

In this updated code:

• RunnableParallel is used to handle the table_chain and ensure it is in the correct format.
• table_chain_runnable is created to combine the input and table_names_to_use keys.

This should resolve the error by ensuring that the table_chain is a Runnable, callable, or dictionary ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[mangeshcodeadda]

@dosu This result i did try already where still i was getting same error,
You can checkout the output below,

table_chain : first=ChatPromptTemplate(input_variables=[], messages=[SystemMessagePromptTemplate(prompt=PromptTemplate(input_variables=[], template="Return the names of ALL the SQL tables that MIGHT be relevant to the user question.
The tables are:
auth_group
auth_group_permissions
auth_permission
auth_user
auth_user_groups
auth_user_user_permissions
bmt_app_client
bmt_app_employee
bmt_app_employee_details
bmt_app_invoice
bmt_app_invoice_count
bmt_app_invoice_employees
bmt_app_invoicegendatesetup
bmt_app_log
bmt_app_pohistory
bmt_app_purchase_order
bmt_app_p(input_variables=[], template='how many clients are presnt in databse'))]) middle=[RunnableBinding(bound=ChatOpenAI(client=<openai.resources.chat.completions.Completions object at 0x0000020EDD684B80>, async_client=<openai.resources.chat.completions.AsyncCompletions object at 0x0000020EDD6864A0>, model_name='gpt-4o-mini', openai_api_key=SecretStr('**********'), openai_proxy=''), kwargs={'tools': [{'type': 'function', 'function': {'name': 'Table', 'description': 'Table in SQL database.', 'parameters': {'type': 'object', 'properties': {'name': {'description': 'Name of table in SQL database.', 'type': 'string'}}, 'required': ['name']}}}]})] last=PydanticToolsParser(tools=[<class 'langchain_module.chaining.Table'>])

table_chain_result : [Table(name='bmt_app_client'), Table(name='bmt_app_userprofile_client')]
In invoke_table_chain() => Expected a Runnable, callable or dict.Instead got an unsupported type: <class 'list'>