Replies: 5 comments 18 replies
-
|
To provide context to your fields like Pathway or Process in your JSON data and to work with JSON data using the JSON Toolkit, you can follow these steps:
Here is an example of how you might structure your JSON data and use the JSON Toolkit: Example JSON Data{
"Data": [
{
"PATHWAY": "XXX",
"PROCESS": "XXX Time to Second Fill",
"Category": "Time to First Fill",
"Year_QTR": 202301,
"Mean_TAT": 46.24399546733213,
"Count_Of_Patients": 2204
},
{
"PATHWAY": "XXX",
"PROCESS": "XXX Time to Second Fill",
"Category": "Time to First Fill",
"Year_QTR": 202302,
"Mean_TAT": 25.79784787346221,
"Count_Of_Patients": 1707
},
{
"PATHWAY": "XXX",
"PROCESS": "XXX Time to First Fill",
"Category": "Time to First Fill",
"Year_QTR": 202303,
"Mean_TAT": 18.62608035545023,
"Count_Of_Patients": 1266
},
{
"PATHWAY": "XXX",
"PROCESS": "XXX Time to First Fill",
"Category": "Time to First Fill",
"Year_QTR": 202304,
"Mean_TAT": 17.50056509433962,
"Count_Of_Patients": 1431
}
]
}Using the JSON ToolkitTo work with this JSON data using the JSON Toolkit, you can follow the guidelines provided in the
Additionally, you can use the Using
|
Beta Was this translation helpful? Give feedback.
-
|
@dosu I am getting this error. Can you help us in giving complete details which including what packages I need to import in each code snippet please? Thank you so much!!!
|
Beta Was this translation helpful? Give feedback.
-
|
To resolve the Here is an example of how you can instantiate and use the from pathlib import Path
from langchain_core.callbacks import CallbackManagerForToolRun
from langchain_core.tools import BaseTool
from langchain_community.tools.json.tool import JsonSpec, JsonListKeysTool
# Create a JsonSpec instance from a file
json_spec = JsonSpec.from_file(Path('path_to_your_json_file.json'))
# Create an instance of JsonListKeysTool
json_list_keys_tool = JsonListKeysTool(spec=json_spec)
# Use the tool to list keys at a given path
tool_input = 'data["key1"][0]["key2"]'
result = json_list_keys_tool._run(tool_input)
print(result)The necessary packages to import for the provided code snippets are: import json
import re
from pathlib import Path
from typing import Dict, List, Optional, Union
from langchain_core.pydantic_v1 import BaseModel
from langchain_core.callbacks import (
AsyncCallbackManagerForToolRun,
CallbackManagerForToolRun,
)
from langchain_core.tools import BaseTool
from langchain_community.tools.json.tool import JsonSpec, JsonListKeysToolMake sure you have these imports at the beginning of your script to avoid any |
Beta Was this translation helpful? Give feedback.
-
|
@dosu in your above example, where I define the context to each field? or detailed description to each field. In the llamaindex we used to describe that in the 'Response_synthesis_prompt'... langchain has any similar one? |
Beta Was this translation helpful? Give feedback.
-
|
To define context or provide detailed descriptions for each field in LangChain, similar to the 'Response_synthesis_prompt' in LlamaIndex, you can use the from langchain_core.prompts.prompt import PromptTemplate
field_description_template = """Given the following fields, provide a detailed description for each field.
Make the descriptions comprehensive and informative. Use every given field.
Fields:
{fields}
Descriptions:
"""
FIELD_DESCRIPTION_PROMPT = PromptTemplate(
template=field_description_template, input_variables=["fields"]
)This template allows you to input fields and generate detailed descriptions for each one. For example, you can define fields and their descriptions as follows: {
"translateRequest": {
"type": "object",
"properties": {
"phrase_to_translate": {
"type": "string",
"required": true,
"description": "Phrase or concept to translate into the foreign language and explain further."
},
"learning_language": {
"type": "string",
"required": true,
"description": "The foreign language that the user is learning and asking about. Always use the full name of the language (e.g. Spanish, French)."
},
"native_language": {
"type": "string",
"required": true,
"description": "The user's native language. Infer this value from the language the user asked their question in. Always use the full name of the language (e.g. Spanish, French)."
},
"additional_context": {
"type": "string",
"required": true,
"description": "A description of any additional context in the user's question that could affect the explanation - e.g. setting, scenario, situation, tone, speaking style and formality, usage notes, or any other qualifiers."
},
"full_query": {
"type": "string",
"required": true,
"description": "Full text of the user's question."
}
}
}
}By using the |
Beta Was this translation helpful? Give feedback.
-
|
@dosu... thank you how I incorporate Can you help me? I am new here... |
Beta Was this translation helpful? Give feedback.
-
|
To incorporate
Here is a complete example: from langchain.agents import AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain_community.agent_toolkits.json.toolkit import JsonToolkit
from langchain_community.agent_toolkits.json.base import create_json_agent
# Define the model
model = ChatOpenAI(model="gpt-4o")
# Define the tool
@tool
def magic_function(input: int) -> int:
"""Applies a magic function to an input."""
return input + 2
tools = [magic_function]
toolkit = JsonToolkit(tools=tools)
# Define the prompt template
system_message = '''Assistant is a large language model trained by OpenAI.
Assistant is designed to be able to assist with a wide range of tasks, from answering \
simple questions to providing in-depth explanations and discussions on a wide range of \
topics. As a language model, Assistant is able to generate human-like text based on \
the input it receives, allowing it to engage in natural-sounding conversations and \
provide responses that are coherent and relevant to the topic at hand.
Assistant is constantly learning and improving, and its capabilities are constantly \
evolving. It is able to process and understand large amounts of text, and can use this \
knowledge to provide accurate and informative responses to a wide range of questions. \
Additionally, Assistant is able to generate its own text based on the input it \
receives, allowing it to engage in discussions and provide explanations and \
descriptions on a wide range of topics.
Overall, Assistant is a powerful system that can help with a wide range of tasks \
and provide valuable insights and information on a wide range of topics. Whether \
you need help with a specific question or just want to have a conversation about \
a particular topic, Assistant is here to assist.'''
human_message = '''TOOLS
------
Assistant can ask the user to use tools to look up information that may be helpful in \
answering the users original question. The tools the human can use are:
{tools}
RESPONSE FORMAT INSTRUCTIONS
----------------------------
When responding to me, please output a response in one of two formats:
**Option 1:**
Use this if you want the human to use a tool.
Markdown code snippet formatted in the following schema:
```json
{{
"action": string, \\ The action to take. Must be one of {tool_names}
"action_input": string \\ The input to the action
}}Option #2: {{
"action": "Final Answer",
"action_input": string \\ You should put what you want to return to use here
}}USER'S INPUTHere is the user's input (remember to respond with a markdown code snippet of a json {input}''' prompt = ChatPromptTemplate.from_messages( Create the agentagent = create_json_agent(model, toolkit, prompt=prompt) Initialize the AgentExecutoragent_executor = AgentExecutor(agent=agent, tools=tools) Invoke the agent executorquery = "what is the value of magic_function(3)?" print(result) |
Beta Was this translation helpful? Give feedback.
-
|
@dosu. I observed that I am not able to load whole my json file until I extend the 'max_value_lenght' like shown below. If I won't extend the number, my results are partial and wrong. How I address the issue in dealing with big json files? do I need to load in vectordb? Please help. This is my code |
Beta Was this translation helpful? Give feedback.
-
|
To split your JSON file into chunks, store it in a vector database, retrieve from the vector database, and search after retrieval using LangChain, follow these steps:
This code will split your JSON file into smaller chunks, store them in a vector database, and allow you to retrieve and search the documents using LangChain. The process follows the typical RAG (Retrieval Augmented Generation) architecture, which involves loading, splitting, storing, retrieving, and generating responses based on the retrieved data [1][2][3]. |
Beta Was this translation helpful? Give feedback.
-
|
@dosu... it did worked. Now how I run my ' The below is my complete code for creating json agent: |
Beta Was this translation helpful? Give feedback.
-
|
To run the # Run the agent on a query
result = json_agent_executor.invoke({"input": "your query here"})
print(result)For example, if you want to ask about the weather in San Francisco, you would do: result = json_agent_executor.invoke({"input": "what's the weather in SF?"})
print(result)This will execute the agent and return the result based on the tools and language model you have set up [1]. |
Beta Was this translation helpful? Give feedback.
-
|
@dosu... Here my question is how I use json_agent_executor on top of retrieved_docs. |
Beta Was this translation helpful? Give feedback.
-
|
To use
Here is a step-by-step example: Define Toolsfrom langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain.tools.retriever import create_retriever_tool
# Load documents and create a retriever
loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
docs = loader.load()
documents = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200).split_documents(docs)
vector = FAISS.from_documents(documents, OpenAIEmbeddings())
retriever = vector.as_retriever()
# Create the retriever tool
retriever_tool = create_retriever_tool(
retriever,
"langsmith_search",
"Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",
)
# Define the list of tools
tools = [retriever_tool]Initialize the Language Modelfrom langchain_openai import AzureChatOpenAI
import os
llm = AzureChatOpenAI(
temperature=0,
azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
api_key=os.getenv("AZURE_OPENAI_API_KEY"),
api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
)Create the Agentfrom langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import AIMessage, HumanMessage
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.agents.format_scratchpad import format_to_openai_function_messages
from langchain_community.tools.convert_to_openai import format_tool_to_openai_function
assistant_system_message = """You are a helpful research assistant. \
Lookup relevant information as needed."""
prompt = ChatPromptTemplate.from_messages(
[
("system", assistant_system_message),
MessagesPlaceholder(variable_name="chat_history"),
("user", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
llm_with_tools = llm.bind(functions=[format_tool_to_openai_function(t) for t in tools])
def _format_chat_history(chat_history):
buffer = []
for human, ai in chat_history:
buffer.append(HumanMessage(content=human))
buffer.append(AIMessage(content=ai))
return buffer
agent = (
{
"input": lambda x: x["input"],
"chat_history": lambda x: _format_chat_history(x["chat_history"]),
"agent_scratchpad": lambda x: format_to_openai_function_messages(
x["intermediate_steps"]
),
}
| prompt
| llm_with_tools
| OpenAIFunctionsAgentOutputParser()
)Create the AgentExecutorfrom langchain.agents import AgentExecutor
from langchain_core.pydantic_v1 import BaseModel, Field
from typing import List, Tuple
class AgentInput(BaseModel):
input: str
chat_history: List[Tuple[str, str]] = Field(
..., extra={"widget": {"type": "chat", "input": "input", "output": "output"}}
)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True).with_types(
input_type=AgentInput
)Run the Agent# Example query to run the agent
response = agent_executor.invoke({"input": "how can langsmith help with testing?", "chat_history": []})
print(response)This setup will allow you to use |
Beta Was this translation helpful? Give feedback.
-
|
@dosu Please help me here... 1. What is the significance of chunk_size and chunk_overlap when dealing with JSON format? Are there any best practice guidelines? |
Beta Was this translation helpful? Give feedback.
-
Significance of
|
Beta Was this translation helpful? Give feedback.
-
|
@dosu While retrieving data from the vector database, I’ve noticed that some data seems to be missing. Even though the data exists in the JSON file, the LLM response sometimes says 'no data found.' However, when I run the code without using the vector database, I get good results. My question is: how can I achieve the same results using the vector database? or is it possible to call code below from the vector retrieval process? Is this possible? Please help. |
Beta Was this translation helpful? Give feedback.
-
|
To achieve the same results using the vector database as you do when running the code directly with 1. Load and Process Your JSON Datafrom pathlib import Path
import json
from langchain.chains import RetrievalQA
from langchain_openai import OpenAI, OpenAIEmbeddings
from langchain_text_splitters import CharacterTextSplitter
from langchain_core.documents import Document
from langchain_community.utilities.sql_database import SQLDatabase
from langchain_experimental.sql.vector_sql import VectorSQLDatabaseChain, VectorSQLOutputParser
# Load JSON data
file_path = "c:/parquet/json/data.json"
data = json.loads(Path(file_path).read_text())
# Assuming you have a way to convert JSON data to text documents
def convert_json_to_documents(data):
documents = []
for item in data["Data"]:
documents.append(Document(page_content=json.dumps(item)))
return documents
documents = convert_json_to_documents(data)
# Split documents into chunks
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)
# Create embeddings
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
# Setup SQL Database
db = SQLDatabase(...) # Configure your SQL database connection here
# Create a VectorSQLDatabaseChain
sql_cmd_parser = VectorSQLOutputParser.from_embeddings(model=embeddings)
vector_sql_chain = VectorSQLDatabaseChain.from_llm(
llm=OpenAI(temperature=0),
db=db,
sql_cmd_parser=sql_cmd_parser
)2. Create a
|
Beta Was this translation helpful? Give feedback.
-
|
@dosu... do you think any other solution other than sqldatabase chain? I have no sql database. |
Beta Was this translation helpful? Give feedback.
-
|
If you don't have a SQL database and want to achieve similar results using the vector database, you can directly use the vector store for retrieval and then process the retrieved documents with your JSON agent. Here is how you can do it: 1. Load and Process Your JSON Datafrom pathlib import Path
import json
from langchain_core.documents import Document
from langchain_text_splitters import RecursiveCharacterTextSplitter
# Load JSON data
file_path = "c:/parquet/json/data.json"
with open(file_path, 'r') as f:
data = json.load(f)
# Convert JSON data to a list of Document objects
def convert_json_to_documents(data):
documents = []
for item in data["Data"]:
documents.append(Document(page_content=json.dumps(item)))
return documents
documents = convert_json_to_documents(data)
# Split documents into smaller chunks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
sub_docs = text_splitter.split_documents(documents)2. Initialize the Vector Store and Store the Chunksfrom langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings
# Initialize vector store
vectorstore = Chroma.from_documents(documents=sub_docs, embedding=OpenAIEmbeddings())3. Set Up the Retrieverretriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 6})4. Create the JSON Agentfrom langchain_community.tools.json.tool import JsonSpec, JsonListKeysTool
from langchain_community.agent_toolkits.json.toolkit import JsonToolkit
from langchain_community.agent_toolkits.json.base import create_json_agent
from langchain_openai import ChatOpenAI
# Create JSON spec and toolkit
json_spec = JsonSpec(dict_=data, max_value_length=10000)
json_toolkit = JsonToolkit(spec=json_spec)
# Initialize the language model
llm = ChatOpenAI(model="gpt-4")
# Create the JSON agent
json_agent_executor = create_json_agent(
llm=llm, toolkit=json_toolkit, verbose=True
)5. Retrieve and Process the Documents# Perform a similarity search
query = "Your search query here"
retrieved_docs = retriever.invoke(query)
# Combine the retrieved documents into a single JSON structure
combined_data = {"Data": [json.loads(doc.page_content) for doc in retrieved_docs]}
# Update the JSON spec with the retrieved data
json_spec = JsonSpec(dict_=combined_data, max_value_length=10000)
json_toolkit = JsonToolkit(spec=json_spec)
# Recreate the JSON agent with the updated toolkit
json_agent_executor = create_json_agent(
llm=llm, toolkit=json_toolkit, verbose=True
)
# Run the agent with the query
result = json_agent_executor.invoke({"input": query})
print(result)This approach allows you to use the vector store for efficient retrieval and then process the retrieved documents with your JSON agent, without needing a SQL database. This method ensures that you can leverage the power of vector-based retrieval while still utilizing your JSON agent for detailed processing and querying [1][2][3]. |
Beta Was this translation helpful? Give feedback.
-
|
@did work. Thank you. 2 Last questions... 1. how I store chromadb locally after embdding? By that I won't embed every time. (please give me sample code) 2. How I execute 'json_agent_executor' after bringing the data out from the chromadb vectors (sample code).... thank you so much. |
Beta Was this translation helpful? Give feedback.
-
|
To store ChromaDB locally after embedding and avoid re-embedding every time, you can use the Storing ChromaDB Locallyfrom langchain_ollama import OllamaEmbeddings
from langchain_chroma import Chroma
from langchain_core.documents import Document
from uuid import uuid4
# Initialize the embeddings
embeddings = OllamaEmbeddings(model="nomic-embed-text")
# Initialize the Chroma vector store with a directory to save data locally
vector_store = Chroma(
collection_name="example_collection",
embedding_function=embeddings,
persist_directory="./chroma_langchain_db", # Directory to save data locally
)
# Add documents to the vector store
documents = [
Document(page_content="I had chocolate chip pancakes and scrambled eggs for breakfast this morning.", metadata={"source": "tweet"}, id=1),
Document(page_content="The weather forecast for tomorrow is cloudy and overcast, with a high of 62 degrees.", metadata={"source": "news"}, id=2),
# Add more documents as needed
]
uuids = [str(uuid4()) for _ in range(len(documents))]
vector_store.add_documents(documents=documents, ids=uuids)
# Persist the vector store to disk
vector_store.persist()Executing
|
Beta Was this translation helpful? Give feedback.
Uh oh!
There was an error while loading. Please reload this page.
-
Checked other resources
Commit to Help
Example Code
Description
How do I provide context to my fields like Pathway or Process in my data? For example, the Pathway field is described as the patient pathway and contains string values. Also, do you suggest any techniques for working with JSON data? I love the JSON toolkit and am looking forward to exploring it more
System Info
Name: langchain
Version: 0.2.15
Beta Was this translation helpful? Give feedback.
All reactions