from langchain_core.prompts import PromptTemplate
from langchain_anthropic import ChatAnthropic
from langchain_core.output_parsers import StrOutputParser

llm = ChatAnthropic(model="claude-sonnet-4-5")

# Step 1: Summarize the input text
summarize_prompt = PromptTemplate.from_template(
    "Summarize the following text in 2 sentences:\n{text}"
)

# Step 2: Generate a blog title from the summary
title_prompt = PromptTemplate.from_template(
    "Write a compelling blog post title for this summary:\n{summary}"
)

parser = StrOutputParser()

# Compose with LCEL pipe operator - each step's output feeds the next
summarize_chain = summarize_prompt | llm | parser
title_chain = title_prompt | llm | parser

# Chain them: text → summary → title
full_pipeline = (
    summarize_chain
    | (lambda summary: {"summary": summary})
    | title_chain
)

text = """LangChain is a Python framework for building LLM-powered applications.
It provides abstractions for prompts, models, retrievers, tools, and memory
so developers can build complex AI workflows without managing raw API logic."""

title = full_pipeline.invoke({"text": text})
print(title)
# Output: "From Raw APIs to Production AI: How LangChain Changes the Game"

from langchain_community.vectorstores import Chroma
from langchain_anthropic import ChatAnthropic
from langchain_openai import OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# Build vector store from your documents
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_texts(
    texts=[
        "LangGraph adds graph-based workflows to LangChain.",
        "Nodes in LangGraph represent tasks or model calls.",
        "Edges define transitions between nodes in the graph.",
        "StateGraph is the main class for building LangGraph workflows.",
    ],
    embedding=embeddings
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# Prompt template that injects retrieved context
rag_prompt = ChatPromptTemplate.from_template("""
Answer the question using only the context below.
If the answer is not in the context, say "I don't have that information."

Context:
{context}

Question: {question}
""")

llm = ChatAnthropic(model="claude-haiku-4-5")  # cheaper model for retrieval tasks

# Full RAG chain: retrieve → format → generate
rag_chain = (
    {
        "context": retriever | (lambda docs: "\n\n".join(d.page_content for d in docs)),
        "question": RunnablePassthrough()
    }
    | rag_prompt
    | llm
    | StrOutputParser()
)

answer = rag_chain.invoke("What is StateGraph used for?")
print(answer)

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, AIMessage
import operator

# The state is a typed dict shared across every node in the graph.
# Annotated with operator.add means new messages are appended, not overwritten.
class ResearchState(TypedDict):
    question: str                              # Original user question
    search_queries: list[str]                  # Queries attempted so far
    search_results: list[str]                  # Raw results from each search
    is_sufficient: bool                        # Does agent have enough info?
    final_answer: str                          # Final synthesized answer
    iteration_count: int                       # Guard against infinite loops

llm = ChatAnthropic(model="claude-sonnet-4-5")

def generate_query(state: ResearchState) -> ResearchState:
    """Generate or refine a search query based on current state."""
    previous = "\n".join(state.get("search_queries", []))
    prompt = f"""Question: {state['question']}
Previous queries tried: {previous or 'none'}
Generate ONE precise search query to answer this question.
If previous queries were tried, refine them to find better results.
Return only the query string, nothing else."""
    
    response = llm.invoke([HumanMessage(content=prompt)])
    query = response.content.strip()
    
    return {
        "search_queries": state.get("search_queries", []) + [query],
        "iteration_count": state.get("iteration_count", 0) + 1
    }

def web_search(state: ResearchState) -> ResearchState:
    """Execute the latest query against a search API."""
    latest_query = state["search_queries"][-1]
    # In production: call Tavily, SerpAPI, or Brave Search here
    result = call_search_api(latest_query)
    return {"search_results": state.get("search_results", []) + [result]}

def evaluate_results(state: ResearchState) -> ResearchState:
    """Decide if we have enough information to answer the question."""
    all_results = "\n---\n".join(state["search_results"])
    prompt = f"""Question: {state['question']}

Search results collected so far:
{all_results}

Do these results contain enough information to provide a complete, 
accurate answer? Reply with only YES or NO."""
    
    response = llm.invoke([HumanMessage(content=prompt)])
    is_sufficient = "YES" in response.content.upper()
    return {"is_sufficient": is_sufficient}

def synthesize_answer(state: ResearchState) -> ResearchState:
    """Write the final answer from all collected results."""
    all_results = "\n---\n".join(state["search_results"])
    prompt = f"""Based on these search results, answer the question comprehensively.
    
Question: {state['question']}
Results: {all_results}

Write a clear, well-structured answer citing the sources."""
    
    response = llm.invoke([HumanMessage(content=prompt)])
    return {"final_answer": response.content}

def should_continue(state: ResearchState) -> str:
    """Routing function: continue searching or synthesize the answer."""
    # Hard cap on iterations to prevent infinite loops
    if state.get("iteration_count", 0) >= 3:
        return "synthesize"
    if state.get("is_sufficient", False):
        return "synthesize"
    return "search_again"

# Build the graph
workflow = StateGraph(ResearchState)

# Register nodes
workflow.add_node("generate_query", generate_query)
workflow.add_node("web_search", web_search)
workflow.add_node("evaluate_results", evaluate_results)
workflow.add_node("synthesize_answer", synthesize_answer)

# Define edges (execution flow)
workflow.set_entry_point("generate_query")
workflow.add_edge("generate_query", "web_search")
workflow.add_edge("web_search", "evaluate_results")

# Conditional edge: loop back or proceed to synthesis
workflow.add_conditional_edges(
    "evaluate_results",
    should_continue,
    {
        "search_again": "generate_query",  # loop back
        "synthesize":   "synthesize_answer"
    }
)
workflow.add_edge("synthesize_answer", END)

# Compile and run
graph = workflow.compile()
result = graph.invoke({
    "question": "What are the key differences between LangChain and LangGraph?",
    "search_queries": [],
    "search_results": [],
    "is_sufficient": False,
    "iteration_count": 0
})
print(result["final_answer"])

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(model="claude-haiku-4-5")

# In-memory store keyed by session_id (replace with Redis/DB for production)
store: dict[str, BaseChatMessageHistory] = {}

def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}"),
])

chain = prompt | llm

# Wraps any chain with automatic per-session history injection
with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history",
)

config = {"configurable": {"session_id": "user-abc"}}

# Each turn is automatically stored and re-injected on the next call
with_history.invoke({"input": "I'm building a Kubernetes cluster for my blog."}, config=config)
with_history.invoke({"input": "I use Ghost CMS on it."}, config=config)
response = with_history.invoke({"input": "What CMS did I mention?"}, config=config)
print(response.content)
# Output: "You mentioned Ghost CMS as your blog platform."

import sqlite3
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.sqlite import SqliteSaver  # langgraph-checkpoint-sqlite package
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, AIMessage
from typing import TypedDict, Annotated
import operator

class ChatState(TypedDict):
    # Annotated with operator.add: new messages are appended to existing list
    messages: Annotated[list, operator.add]

llm = ChatAnthropic(model="claude-haiku-4-5")

def chat_node(state: ChatState) -> ChatState:
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

workflow = StateGraph(ChatState)
workflow.add_node("chat", chat_node)
workflow.set_entry_point("chat")
workflow.add_edge("chat", END)

# SqliteSaver persists state to disk - swap for MemorySaver in tests, PostgresSaver in prod
conn = sqlite3.connect("checkpoints.db", check_same_thread=False)
checkpointer = SqliteSaver(conn)
graph = workflow.compile(checkpointer=checkpointer)

# thread_id identifies the conversation session - same ID = same memory
config = {"configurable": {"thread_id": "user-idir-session-001"}}

# Session 1
graph.invoke(
    {"messages": [HumanMessage(content="My name is Idir and I run a DevOps blog.")]},
    config=config
)

# Session 2 - days later, new process, same thread_id
response = graph.invoke(
    {"messages": [HumanMessage(content="What kind of blog did I say I run?")]},
    config=config
)
# Output includes full history: "You mentioned running a DevOps blog."

from typing import Literal

def route_by_intent(state: dict) -> Literal["search_web", "query_database", "generate_code", "human_review"]:
    """Classify the user's intent and route to the appropriate handler."""
    intent = state.get("classified_intent", "unknown")
    confidence = state.get("confidence_score", 0.0)
    
    # Low confidence always routes to human
    if confidence < 0.7:
        return "human_review"
    
    intent_map = {
        "web_search": "search_web",
        "data_query": "query_database",
        "code_task":  "generate_code",
    }
    return intent_map.get(intent, "human_review")

# Wire into graph
workflow.add_conditional_edges(
    "classify_intent",  # source node
    route_by_intent,      # routing function
    {                     # mapping: return value → destination node
        "search_web":    "web_search_node",
        "query_database":"db_query_node",
        "generate_code": "code_gen_node",
        "human_review":  "human_review_node",
    }
)

import sqlite3
from langgraph.checkpoint.sqlite import SqliteSaver

conn = sqlite3.connect("checkpoints.db", check_same_thread=False)
checkpointer = SqliteSaver(conn)

# Compile with an interrupt BEFORE the "publish" node executes
graph = workflow.compile(
    checkpointer=checkpointer,
    interrupt_before=["publish_article"]  # pause here for human review
)

config = {"configurable": {"thread_id": "article-draft-001"}}

# Run the graph - it will pause before "publish_article"
result = graph.invoke(initial_state, config=config)
# At this point, execution is paused. The state is persisted.

# Inspect the draft before publishing
current_state = graph.get_state(config)
draft = current_state.values["article_draft"]
print(f"Draft ready for review:\n{draft}")

# Human modifies the draft if needed
graph.update_state(
    config,
    {"article_draft": "[Human-edited version of the draft]"}
)

# Resume execution from the checkpoint - publishes the edited draft
final = graph.invoke(None, config=config)

# Enable LangSmith tracing - set before running any LangChain/LangGraph code
export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="your_langsmith_api_key"
export LANGCHAIN_PROJECT="devops-blog-agent"  # organizes traces by project

# Everything runs normally - traces appear automatically in smith.langchain.com

from fastapi import FastAPI
from langserve import add_routes
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

app = FastAPI(title="DevOps Blog API")
llm = ChatAnthropic(model="claude-haiku-4-5")

# Define your chain
chain = (
    ChatPromptTemplate.from_template("Explain {topic} in simple terms.")
    | llm
    | StrOutputParser()
)

# One line to expose it as a REST endpoint
add_routes(app, chain, path="/explain")

# Run: uvicorn main:app --reload
# Auto-generated endpoints:
# POST /explain/invoke       → single call
# POST /explain/stream       → streaming response
# GET  /explain/playground   → interactive UI
# GET  /explain/openapi.json → OpenAPI spec