Migrating from LangChain

from langchain.chat_models import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import Tool

# Initialize LLM
llm = ChatOpenAI(
    model_name="gpt-4",
    temperature=0.7
)

# Define tools
tools = [
    Tool(
        name="web_search",
        func=lambda x: search_web(x),
        description="Search the web for information"
    )
]

# Create agent
agent = create_react_agent(llm, tools)
executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True
)

# Run
result = executor.invoke({"input": "What's the weather?"})

from langchain.chat_models import ChatAnthropic
from langchain.agents import initialize_agent
from langchain.tools import StructuredTool

def fetch_data(url: str, max_results: int = 10):
    """Fetch data from a URL."""
    return requests.get(url).json()

def process_data(data: dict):
    """Process fetched data."""
    return {"processed": True, "count": len(data)}

llm = ChatAnthropic(model="claude-3-sonnet")

tools = [
    StructuredTool.from_function(
        func=fetch_data,
        name="fetch_data",
        description="Fetch data from a URL"
    ),
    StructuredTool.from_function(
        func=process_data,
        name="process_data",
        description="Process fetched data"
    )
]

agent = initialize_agent(
    tools,
    llm,
    agent="zero-shot-react-description",
    verbose=True
)

from langchain.chains import LLMChain, SequentialChain
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(model="gpt-4")

# Chain 1: Generate outline
outline_prompt = PromptTemplate(
    input_variables=["topic"],
    template="Create an outline for: {topic}"
)
outline_chain = LLMChain(llm=llm, prompt=outline_prompt, output_key="outline")

# Chain 2: Write content
content_prompt = PromptTemplate(
    input_variables=["outline"],
    template="Write content based on: {outline}"
)
content_chain = LLMChain(llm=llm, prompt=content_prompt, output_key="content")

# Sequential chain
full_chain = SequentialChain(
    chains=[outline_chain, content_chain],
    input_variables=["topic"],
    output_variables=["outline", "content"]
)

result = full_chain({"topic": "AI agents"})

from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

llm = ChatOpenAI(model="gpt-4")
memory = ConversationBufferMemory()
embeddings = OpenAIEmbeddings()

vectorstore = Chroma(
    collection_name="conversations",
    embedding_function=embeddings
)

conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

response = conversation.predict(input="Hello, I'm learning about agents")