import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const model = new ChatOpenAI({ model: "gpt-4o" });
const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a helpful assistant."],
  ["human", "{input}"],
]);
const outputParser = new StringOutputParser();

const chain = prompt.pipe(model).pipe(outputParser);

const result = await chain.invoke({ input: "Explain quantum computing" });
console.log(result);

from langchain_core.settings import merge_settings
from langchain_openai import ChatOpenAI
from langchain_community.chat_models import ChatAnthropic

# Load settings from environment
settings = merge_settings(
    {"default_api_key": "sk-..."},
    {"model_name": "claude-3-opus"},
)

# Create model with settings
model = ChatOpenAI(settings=settings)

from langchain.tools import tool

@tool
def search_wikipedia(query: str) -> str:
    """Search Wikipedia and return the summary."""
    from langchain_community.tools import WikipediaQueryRun
    return WikipediaQueryRun().run(query)

# Register multiple tools
tools = [search_wikipedia, ...]  # Add more tools

from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory, ConversationSummaryMemory

# Simple buffer memory
buffer_mem = ConversationBufferMemory()
buffer_mem.save_context({"human": "Hello"}, {"ai": "Hi there!"})

# Summary memory (uses LLM to summarize)
summary_mem = ConversationSummaryMemory(llm=model)

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

# Split documents into chunks
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
)
chunks = text_splitter.split_documents(documents)

# Create vector store
vectorstore = FAISS.from_documents(chunks, OpenAIEmbeddings())

# Create retriever
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

# Build RAG chain
from langchain.chains import RetrievalQA
qa_chain = RetrievalQA.from_chain_type(
    llm=model,
    chain_type="stuff",
    retriever=retriever,
)
result = qa_chain.run("What are the main findings?")

from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

# Define agents with specific roles
researcher = Agent(
    role="Senior Research Analyst",
    goal="Uncover cutting-edge developments in AI",
    backstory="""You're a senior researcher at a top tech think tank.
    Your job is to monitor industry trends and identify opportunities.""",
    verbose=True,
    allow_delegation=True,
)

writer = Agent(
    role="Technical Content Writer",
    goal="Write compelling articles about AI developments",
    backstory="""You're a technical writer specializing in AI.
    You translate complex research into accessible articles.""",
    verbose=True,
)

# Define tasks
research_task = Task(
    description="Research the latest advancements in LLM agent frameworks",
    expected_output="A detailed report with key findings and trends",
    agent=researcher,
)

writing_task = Task(
    description="Write a comprehensive blog post based on the research",
    expected_output="A 1500-word article with clear sections and code examples",
    agent=writer,
)

# Assemble the crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff()
print(result)

{
  "crews": [
    {
      "name": "research_crew",
      "agents": [
        {
          "role": "Researcher",
          "goal": "Find relevant information",
          "backstory": "Expert researcher",
          "llm": {"provider": "openai", "config": {"model": "gpt-4o"}}
        }
      ],
      "tasks": [
        {
          "description": "Research topic X",
          "expected_output": "Report",
          "agent": "Researcher"
        }
      ]
    }
  ]
}

from crewai import Crew, Process

# Hierarchical mode: manager agent delegates to team members
crew = Crew(
    agents=[manager, researcher, writer],
    tasks=[manager_task, research_task, writing_task],
    process=Process.hierarchical,
    manager_llm=ChatOpenAI(model="gpt-4o"),
)

from crewai.tools import BaseTool
from pydantic import BaseModel, Field

class WebSearchInput(BaseModel):
    query: str = Field(description="The search query")

class WebSearchTool(BaseTool):
    name: str = "Web Search"
    description: str = "Search the web for information"
    args_schema: type[BaseModel] = WebSearchInput

    def _run(self, query: str) -> str:
        # Implement your search logic
        return f"Results for: {query}"

import autogen
from autogen import AssistantAgent, UserProxyAgent

# Configure LLM
config_list = [
    {
        "model": "gpt-4o",
        "api_key": "your-api-key",
    }
]

# Define agents
assistant = AssistantAgent(
    name="assistant",
    llm_config={"config_list": config_list, "temperature": 0},
    system_message="You are a helpful AI assistant. Solve tasks collaboratively.",
)

user_proxy = UserProxyAgent(
    name="user",
    human_input_mode="NEVER",
    is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
    code_execution_config={
        "work_dir": "coding",
        "use_docker": False,
    },
)

# Initiate conversation
user_proxy.initiate_chat(
    assistant,
    message="""Write a Python function that implements a binary search tree.
    Include insert, search, and delete operations. TERMINATE""",
)

from autogen import GroupChat, GroupChatManager

# Define participants
participants = [user_proxy, assistant, coder, reviewer]

# Create group chat
group_chat = GroupChat(
    agents=participants,
    messages=[],
    max_round=10,
    speaker_selection_method="round_robin",
)

# Create manager
manager = GroupChatManager(groupchat=group_chat)

# Initiate
user_proxy.initiate_chats([
    {"recipient": manager, "message": "Write a Python script for data analysis", "clear_history": True}
])

from autogen.function_utils import get_function_schema

def calculate_bmi(weight_kg: float, height_cm: float) -> dict:
    """Calculate BMI from weight and height."""
    bmi = weight_kg / ((height_cm / 100) ** 2)
    return {"bmi": round(bmi, 1), "category": "normal" if 18.5 <= bmi < 25 else "other"}

# Register function with agent
schema = get_function_schema(calculate_bmi)

import autogen

config_list = [{"model": "gpt-4o", "api_key": "sk-..."}]

coder = autogen.AssistantAgent(
    name="coder",
    llm_config={"config_list": config_list},
    system_message="You are a Python coder. Write clean, tested code.",
)

executor = autogen.UserProxyAgent(
    name="executor",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "coding", "use_docker": False},
)

executor.initiate_chat(coder, message="Write a Flask API for a todo list app")

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.openai import OpenAI

# Configure settings
Settings.llm = OpenAI(model="gpt-4o")

# Load and index documents
documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(documents)

# Create query engine
query_engine = index.as_query_engine(similarity_top_k=5)

# Query the index
response = query_engine.query("What are the key findings about AI agents?")
print(response.response)

# Advanced: Knowledge Graph Index
from llama_index.core.indices.knowledge_graph import KnowledgeGraphIndex

kg_index = KnowledgeGraphIndex.from_documents(
    documents,
    max_triplets_per_chunk=5,
)
kg_query_engine = kg_index.as_query_engine(include_text=True)

from llama_index.readers.file import PDFReader, ImageReader

# Read PDF documents
pdf_reader = PDFReader()
pdf_docs = pdf_reader.load_data(file="./document.pdf")

# Read images with OCR
image_reader = ImageReader()
image_docs = image_reader.load_data(file="./diagram.png")

from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.embeddings.cohere import CohereEmbedding

# OpenAI embeddings (default)
openai_embed = OpenAIEmbedding(model="text-embedding-3-large")

# Cohere embeddings (often better for semantic search)
cohere_embed = CohereEmbedding(model="embed-english-v3.0")

Settings.embed_model = cohere_embed

from llama_index.core.node_parser import SentenceWindowNodeParser, MarkdownNodeParser

# Sentence window parser (preserves context around chunks)
sentence_parser = SentenceWindowNodeParser.from_defaults(
    window_size=3,
    window_metadata_key="window",
    original_content_metadata_key="original_content",
)

# Markdown parser (preserves document structure)
markdown_parser = MarkdownNodeParser()
nodes = markdown_parser.get_nodes_from_documents(documents)

from llama_index.core.indices.prompt_helper import PromptHelper
from llama_index.core.retrievers import VectorIndexRetriever

# Create multiple indexes for different document types
tech_index = VectorStoreIndex.from_documents(tech_docs)
legal_index = VectorStoreIndex.from_documents(legal_docs)

# Route queries based on keywords
def route_query(query: str):
    if any(kw in query.lower() for kw in ["patent", "copyright", "trademark"]):
        return legal_index.as_retriever()
    else:
        return tech_index.as_retriever()

from langgraph.graph import StateGraph, START, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    checker: str

def chatbot(state: AgentState):
    from langchain_openai import ChatOpenAI
    response = ChatOpenAI().invoke(state["messages"])
    return {"messages": [response]}

def checker(state: AgentState):
    if len(state["messages"])[-1].content > 100:
        return "approved"
    return "needs_revision"

def revise(state: AgentState):
    from langchain_openai import ChatOpenAI
    messages = state["messages"] + [
        {"role": "user", "content": "Make it shorter. Under 100 characters."}
    ]
    response = ChatOpenAI().invoke(messages)
    return {"messages": [response]}

# Build the graph
workflow = StateGraph(AgentState)
workflow.add_node("chatbot", chatbot)
workflow.add_node("checker", checker)
workflow.add_node("revise", revise)

# Define edges
workflow.add_edge(START, "chatbot")
workflow.add_conditional_edges(
    "chatbot",
    checker,
    {"approved": END, "needs_revision": "revise"}
)
workflow.add_edge("revise", "chatbot")

app = workflow.compile()

from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import create_react_agent

# Set up memory for checkpointing
checkpointer = MemorySaver()

# Create agent with human-in-the-loop
agent = create_react_agent(
    model,
    tools,
    checkpointer=checkpointer,
)

# Invoke with thread for checkpointing
config = {"configurable": {"thread_id": "thread-1"}}
result = agent.invoke({"messages": [("human", "Book a flight to Tokyo")]}, config)

# The agent pauses at tool calls for approval
# Resume with:
# result = agent.invoke(None, config)

from langchain_core.messages import AIMessageChunk

# Stream agent execution
for event in agent.stream(
    {"messages": [("human", "Write a poem about AI")]},
    config={"stream_mode": "values"},
):
    last_msg = event["messages"][-1]
    if isinstance(last_msg, AIMessageChunk):
        print(last_msg.content, end="", flush=True)

from langgraph.graph import StateGraph

# Define subgraph for research phase
research_graph = StateGraph(ResearchState)
research_graph.add_node("search", search_nodes)
research_graph.add_node("analyze", analyze_nodes)
research_graph.add_edge("search", "analyze")
research_graph.set_entry_point("search")
research_compiled = research_graph.compile()

# Use subgraph in main workflow
main_graph = StateGraph(MainState)
main_graph.add_node("research", research_compiled)
main_graph.add_node("write", write_nodes)
main_graph.add_edge("research", "write")
main_graph.set_entry_point("research")
workflow = main_graph.compile()

import asyncio
from functools import wraps

def retry_with_backoff(max_retries=3, base_delay=1.0):
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return await func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_retries - 1:
                        raise
                    delay = base_delay * (2 ** attempt)
                    await asyncio.sleep(delay)
        return wrapper
    return decorator

@retry_with_backoff(max_retries=3)
async def call_llm_with_retry(prompt):
    response = await model.ainvoke(prompt)
    return response

FROM python:3.12-slim

WORKDIR /app

# Install framework dependencies
RUN pip install --no-cache-dir \
    langchain \
    langchain-openai \
    crewai \
    autogen-agentchat \
    llama-index-core \
    llama-index-llms-openai \
    langgraph

# Install development tools
RUN pip install --no-cache-dir \
    ipython \
    jupyterlab \
    ruff \
    mypy

# Copy project files
COPY . .

# Set environment variables
ENV OPENAI_API_KEY=${OPENAI_API_KEY}
ENV LANGCHAIN_TRACING_V2=true
ENV LANGCHAIN_API_KEY=${LANGCHAIN_API_KEY}

CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

docker build -t ai-frameworks-dev .
docker run -p 8888:8888 -v $(pwd):/app ai-frameworks-dev