GenerateAnswerNode

class GenerateAnswerNode(BaseNode):
    def __init__(
        self,
        input: str,
        output: List[str],
        node_config: Optional[dict] = None,
        node_name: str = "GenerateAnswer",
    )

def execute(self, state: dict) -> dict:
    """
    Executes the GenerateAnswerNode.
    
    Args:
        state (dict): The current state of the graph.
    
    Returns:
        dict: The updated state with the output key containing the generated answer.
    """

def invoke_with_timeout(self, chain, inputs, timeout):
    """Helper method to invoke chain with timeout"""

from scrapegraphai.nodes import GenerateAnswerNode
from langchain_openai import ChatOpenAI

# Create generate answer node
generate_node = GenerateAnswerNode(
    input="user_prompt & parsed_doc",
    output=["answer"],
    node_config={
        "llm_model": ChatOpenAI(model="gpt-4"),
        "verbose": False,
        "timeout": 480
    }
)

# Execute node
state = {
    "user_prompt": "What is the main topic of this article?",
    "parsed_doc": ["Article content chunk 1...", "Article content chunk 2..."]
}
updated_state = generate_node.execute(state)

print(updated_state["answer"])
# Output: {"content": "The main topic is..."}

from pydantic import BaseModel, Field
from typing import List

class ProductInfo(BaseModel):
    name: str = Field(description="Product name")
    price: float = Field(description="Product price")
    features: List[str] = Field(description="List of product features")

generate_node = GenerateAnswerNode(
    input="user_prompt & document",
    output=["answer"],
    node_config={
        "llm_model": ChatOpenAI(model="gpt-4"),
        "schema": ProductInfo,  # Define output structure
        "verbose": True
    }
)

state = {
    "user_prompt": "Extract product information",
    "document": [Document(page_content="Product page content...")]
}
updated_state = generate_node.execute(state)

print(updated_state["answer"])
# Output: {"name": "...", "price": 99.99, "features": [...]}

generate_node = GenerateAnswerNode(
    input="user_prompt & parsed_doc",
    output=["answer"],
    node_config={
        "llm_model": ChatOpenAI(model="gpt-4"),
        "verbose": True,  # Show progress bar
        "timeout": 600  # Longer timeout for multiple chunks
    }
)

state = {
    "user_prompt": "Summarize all the key points",
    "parsed_doc": [
        "Chunk 1 content...",
        "Chunk 2 content...",
        "Chunk 3 content...",
        "Chunk 4 content..."
    ]
}
updated_state = generate_node.execute(state)
# Processes all chunks in parallel, then merges results

from langchain_community.chat_models import ChatOllama

generate_node = GenerateAnswerNode(
    input="user_prompt & document",
    output=["answer"],
    node_config={
        "llm_model": ChatOllama(model="llama3"),
        "verbose": False
    }
)

state = {
    "user_prompt": "Extract contact information",
    "document": [Document(page_content="Contact page content...")]
}
updated_state = generate_node.execute(state)

generate_node = GenerateAnswerNode(
    input="user_prompt & parsed_doc",
    output=["answer"],
    node_config={
        "llm_model": ChatOpenAI(model="gpt-4"),
        "additional_info": """You are a financial analyst. 
                             Focus on extracting numerical data and financial metrics.""",
        "verbose": False
    }
)

state = {
    "user_prompt": "What are the company's financial metrics?",
    "parsed_doc": ["Financial report content..."]
}
updated_state = generate_node.execute(state)

generate_node = GenerateAnswerNode(
    input="user_prompt & document",
    output=["answer"],
    node_config={
        "llm_model": ChatOpenAI(model="gpt-4"),
        "is_md_scraper": True,  # Optimized for markdown content
        "force": True
    }
)

state = {
    "user_prompt": "Extract all code examples",
    "document": [Document(page_content="# Tutorial\n\n```python\n...")]
}
updated_state = generate_node.execute(state)

from langchain_aws import ChatBedrock

generate_node = GenerateAnswerNode(
    input="user_prompt & parsed_doc",
    output=["answer"],
    node_config={
        "llm_model": ChatBedrock(
            model_id="anthropic.claude-3-sonnet-20240229-v1:0",
            region_name="us-east-1"
        ),
        "verbose": False
    }
)

state = {
    "user_prompt": "Analyze the sentiment",
    "parsed_doc": ["Customer reviews content..."]
}
updated_state = generate_node.execute(state)

# Triggered when len(doc) == 1
state = {
    "user_prompt": "Extract info",
    "parsed_doc": ["Single chunk content"]
}

# Triggered when len(doc) > 1
state = {
    "user_prompt": "Extract info",
    "parsed_doc": ["Chunk 1", "Chunk 2", "Chunk 3"]
}

node_config = {
    "llm_model": ChatOpenAI(model="gpt-4"),
    "schema": YourPydanticModel
}
# Output is parsed into Pydantic model structure

node_config = {
    "llm_model": ChatOpenAI(model="gpt-4")
}
# Output is parsed as generic JSON with 'content' field
# Example: {"content": "your analysis here"}

state = {"answer": {
    "error": "Response timeout exceeded",
    "raw_response": "..."
}}

state = {"answer": {
    "error": "Invalid JSON response format",
    "raw_response": "..."
}}

# Raises ValueError: "No content found in state to generate answer from"

# Raises ValueError: "No user prompt found in state"

chains_dict = {
    "chunk1": prompt1 | llm_model,
    "chunk2": prompt2 | llm_model,
    "chunk3": prompt3 | llm_model,
}
async_runner = RunnableParallel(**chains_dict)
results = async_runner.invoke({"question": user_prompt})

Processing chunks: 100%|██████████| 5/5 [00:12<00:00, 2.5s/chunk]