is there any way to show a table as an output through open ai api's?

[deepak-hl]

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

def retreival_qa_chain(chat_history_session, prompt, not_uuid):
    embedding = OpenAIEmbeddings()
    # llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.5)
    llm=ChatOpenAI(model="gpt-4o-mini", temperature=0.5)
    # vector_store = PGVector(
    #     connection_string=CONNECTION_STRING,
    #     collection_name=not_uuid,
    #     embedding_function=embedding,
    # )
    vector_store = Qdrant(
        client=client,
        collection_name=not_uuid,
        embeddings=embedding
        )
    retriever = vector_store.as_retriever(search_kwargs={"k": 8})
    message_history = get_message_history_db(
        chat_history_session, DATABASE_NAME_HISTORY
    )

    user_exp_obj = UserExperience.objects.get(not_uuid=not_uuid)
    memory_key = user_exp_obj.memorizing
    memory = ConversationBufferMemory(
        memory_key="chat_history",
        return_messages=True,
        chat_memory=message_history,
        output_key="answer",
    )
    if memory_key == False:
        memory.clear()
    if memory_key:
        chain = ConversationalRetrievalChain.from_llm(
            llm=llm,
            retriever=retriever,
            return_source_documents=True,
            memory=memory,
            combine_docs_chain_kwargs={"prompt": prompt},
            rephrase_question=False,
        )
    else:
        chain = RetrievalQA.from_chain_type(
            llm=llm,
            retriever=retriever,
            return_source_documents=True,
            chain_type_kwargs={"prompt": prompt},
        )
    print(chain,"********************88")
    return chain

Description

is there any way to show a table as an output through open ai api's?
ans = new_project_qa.invoke(query)
try:
ans_output = ans["answer"]
except:
ans_output = ans["result"]

System Info

langchain
ubuntu

[dosubot[bot]]

Yes, you can show a table as an output through OpenAI APIs by defining a custom output schema using Pydantic. Here is an example of how you can achieve this:

from typing import List
from pydantic import BaseModel, Field
from langchain.chains.openai_functions import create_qa_with_structure_chain
from langchain.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate
from langchain_core.messages import HumanMessage, SystemMessage

class TableResponseSchema(BaseModel):
    """A table response schema."""
    headers: List[str] = Field(..., description="Headers of the table")
    rows: List[List[str]] = Field(..., description="Rows of the table")

prompt_messages = [
    SystemMessage(
        content=(
            "You are a world class algorithm to answer "
            "questions in a specific format."
        )
    ),
    HumanMessage(content="Answer question using the following context"),
    HumanMessagePromptTemplate.from_template("{context}"),
    HumanMessagePromptTemplate.from_template("Question: {question}"),
    HumanMessage(
        content="Tips: Make sure to answer in the correct format. Return the table with headers and rows."
    ),
]

chain_prompt = ChatPromptTemplate(messages=prompt_messages)

qa_chain_pydantic = create_qa_with_structure_chain(
    llm, TableResponseSchema, output_parser="pydantic", prompt=chain_prompt
)
final_qa_chain_pydantic = StuffDocumentsChain(
    llm_chain=qa_chain_pydantic,
    document_variable_name="context",
    document_prompt=doc_prompt,
)
retrieval_qa_pydantic = RetrievalQA(
    retriever=docsearch.as_retriever(), combine_documents_chain=final_qa_chain_pydantic
)
query = "What did he say about russia"
result = retrieval_qa_pydantic.run(query)

This code sets up a custom response schema for a table with headers and rows, and configures the OpenAI API to return responses in this format ^[1].

Additionally, you can use LangChain to interact with CSV data and generate tables. Here is an example of how you can use LangChain with Pandas to generate a table:

import pandas as pd
from langchain_experimental.tools import PythonAstREPLTool

df = pd.read_csv("titanic.csv")
tool = PythonAstREPLTool(locals={"df": df})
tool.invoke("df.head().to_markdown()")

This approach allows you to load a CSV file as a dataframe and use a Python-executing tool to generate a table ^[2].

For more advanced use cases, you can create a chain or an agent to interact with the data and generate tables based on user queries.

To continue talking to Dosu, mention @dosu.