Agentic Design Patterns

https://docs.google.com/document/d/
Admin
A comprehensive guide to building intelligent AI agents using fundamental design patterns including...
Tokens:5,698
Snippets:18
Trust Score:5
Update:1 year ago
Show doc for...
Tokens:
Raw
### Planning Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code examples illustrating planning capabilities for AI agents. These snippets demonstrate how agents can create and follow a sequence of steps to achieve a high-level goal.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7)

# Define a planning prompt
plan_prompt = PromptTemplate(
    input_variables=["goal"],
    template="Create a step-by-step plan to achieve the following goal: {goal}\nPlan:"
)
plan_chain = LLMChain(llm=llm, prompt=plan_prompt)

# Define a task execution prompt based on a plan step
execute_prompt = PromptTemplate(
    input_variables=["step"],
    template="Execute the following step: {step}\nResult:"
)
execute_chain = LLMChain(llm=llm, prompt=execute_prompt)

goal = "Book a flight from New York to London"

# Generate the plan
plan = plan_chain.run(goal)
print(f"Plan to achieve '{goal}':\n{plan}\n")

# Simulate executing the plan step-by-step
plan_steps = plan.split('\n') # Basic splitting, might need more sophisticated parsing
for i, step in enumerate(plan_steps):
    if step.strip(): # Ensure step is not empty
        print(f"Executing Step {i+1}: {step}")
        result = execute_chain.run(step)
        print(f"Result: {result}\n")
```

--------------------------------

### Reflection Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets illustrating the reflection pattern for AI agents. These examples demonstrate how an agent can analyze its own performance or output and adjust its strategy accordingly.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7)

# Prompt for initial task execution
execution_prompt = PromptTemplate(
    input_variables=["query"],
    template="Answer the following question: {query}"
)
execution_chain = LLMChain(llm=llm, prompt=execution_prompt)

# Prompt for reflection and improvement
reflection_prompt = PromptTemplate(
    input_variables=["question", "answer"],
    template="Question: {question}\nAnswer: {answer}\nCritique the answer and suggest improvements for a better response. If the answer is good, say it is good."
)
reflection_chain = LLMChain(llm=llm, prompt=reflection_prompt)

query = "What is the capital of France?"
initial_answer = execution_chain.run(query)
print(f"Initial Answer: {initial_answer}")

reflection_on_answer = reflection_chain.run(question=query, answer=initial_answer)
print(f"Reflection: {reflection_on_answer}")

# If reflection indicates improvement is needed, re-run with refined approach (example)
if "improve" in reflection_on_answer.lower():
    refined_prompt = PromptTemplate(
        input_variables=["query", "reflection"],
        template="Answer the following question, considering this feedback: {query}\nFeedback: {reflection}"
    )
    refined_chain = LLMChain(llm=llm, prompt=refined_prompt)
    final_answer = refined_chain.run(query=query, reflection=reflection_on_answer)
    print(f"Refined Answer: {final_answer}")
else:
    print("Initial answer was satisfactory.")
```

--------------------------------

### Human-in-the-Loop Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets demonstrating human-in-the-loop (HITL) integration for AI agents. These examples show how human feedback or intervention can be incorporated into agent workflows.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7)

# Prompt for initial task generation
initial_task_prompt = PromptTemplate(
    input_variables=["topic"],
    template="Generate a task related to {topic}. Task:"
)
initial_task_chain = LLMChain(llm=llm, prompt=initial_task_prompt)

# Prompt for human review/correction
human_review_prompt = PromptTemplate(
    input_variables=["generated_task", "human_feedback"],
    template="Review the following task: \"{generated_task}\".\nHuman Feedback: \"{human_feedback}\".\nProvide a revised task based on the feedback."
)
human_review_chain = LLMChain(llm=llm, prompt=human_review_prompt)

topic = "summarizing documents"

# Agent generates a task
agent_task = initial_task_chain.run(topic)
print(f"Agent Generated Task: {agent_task}\n")

# Simulate human feedback
human_feedback = "Make the task more specific about the document type."

# Agent revises the task based on feedback
revised_task = human_review_chain.run(generated_task=agent_task, human_feedback=human_feedback)
print(f"Human Feedback: {human_feedback}\nRevised Task: {revised_task}")
```

--------------------------------

### Goal Setting and Monitoring Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets demonstrating goal setting and monitoring for AI agents. These examples show how agents can define objectives and track their progress towards achieving them.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7)

# Define a goal setting prompt
goal_setting_prompt = PromptTemplate(
    input_variables=["objective"],
    template="Break down the objective \"{objective}\" into smaller, measurable goals."
)
goal_setting_chain = LLMChain(llm=llm, prompt=goal_setting_prompt)

# Define a monitoring prompt
monitoring_prompt = PromptTemplate(
    input_variables=["current_status", "goal"],
    template="Current status: {current_status}\nGoal: {goal}\nProvide an update on progress towards the goal."
)
monitoring_chain = LLMChain(llm=llm, prompt=monitoring_prompt)

objective = "Write a 500-word blog post about AI agents"

# Set the goals
sub_goals = goal_setting_chain.run(objective)
print(f"Objective: {objective}\nSub-goals:\n{sub_goals}\n")

# Simulate progress monitoring
current_status = "Drafted the introduction and first section."
progress_update = monitoring_chain.run(current_status=current_status, goal=objective)
print(f"Progress Update:\n{progress_update}")

current_status_2 = "Completed the first draft of the blog post."
progress_update_2 = monitoring_chain.run(current_status=current_status_2, goal=objective)
print(f"Progress Update:\n{progress_update_2}")
```

--------------------------------

### Routing Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets illustrating routing mechanisms for AI agents. These examples show how to direct agent tasks or queries to appropriate sub-agents or tools based on specific criteria.

```python
from langchain.chains.router import MultiPromptChain
from langchain.chains.router.llm_router import LLMRouterChain
from langchain.chains.router.multi_prompt_chain import Route
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

llm = OpenAI(temperature=0)

# Define different prompt chains for different tasks
physics_template = "A question about physics: {input}"
math_template = "A question about math: {input}"

# Define the routes
physics_route = Route(
    name="Physics",
    description="Good for physics questions",
    ldots=PromptTemplate.from_template(physics_template)
)

math_route = Route(
    name="Math",
    description="Good for math questions",
    ldots=PromptTemplate.from_template(math_template)
)

# Create the router chain
router_chain = LLMRouterChain.from_routes([
    physics_route,
    math_route
], 
    llm=llm,
    output_key="route"
)

# Create the multi-prompt chain
multi_prompt_chain = MultiPromptChain(
    router_chain=router_chain,
    llm=llm,
    verbose=True,
    output_key="output"
)

# Example usage
response = multi_prompt_chain.run("What is the speed of light?")
print(response)

response = multi_prompt_chain.run("What is 2 + 2?")
print(response)
```

--------------------------------

### Multi-Agent System Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets for building and managing multi-agent systems. These examples show how multiple AI agents can collaborate or interact to solve complex problems.

```python
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import Tool
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

llm = OpenAI(temperature=0.7)

# Define a tool for Agent 1 (e.g., Research)
def research_tool(query: str) -> str:
    # In a real scenario, this would call a search API
    return f"Research results for '{query}'."

# Define a tool for Agent 2 (e.g., Summarize)
def summarize_tool(text: str) -> str:
    # In a real scenario, this would call a summarization model
    return f"Summary of '{text[:50]}...'."

# Agent 1: Researcher
research_prompt = PromptTemplate.from_template(
    "You are a helpful researcher. Your task is to find information. Query: {input}"
)
agent1_tools = [
    Tool(
        name="Research",
        func=research_tool,
        description="Useful for finding information about a given query."
    )
]
agent1_chain = create_react_agent(llm, agent1_tools, research_prompt)
agent1_executor = AgentExecutor(agent=agent1_chain, tools=agent1_tools, verbose=True)

# Agent 2: Summarizer
summarize_prompt = PromptTemplate.from_template(
    "You are a helpful summarizer. Your task is to summarize provided text. Text: {input}"
)
agent2_tools = [
    Tool(
        name="Summarize",
        func=summarize_tool,
        description="Useful for summarizing text."
    )
]
agent2_chain = create_react_agent(llm, agent2_tools, summarize_prompt)
agent2_executor = AgentExecutor(agent=agent2_chain, tools=agent2_tools, verbose=True)

# Interaction: Agent 1 finds info, Agent 2 summarizes it
query_for_agent1 = "Latest advancements in AI"
research_result = agent1_executor.run(query_for_agent1)
print(f"Agent 1 Result: {research_result}\n")

summary_result = agent2_executor.run(research_result)
print(f"Agent 2 Result: {summary_result}")
```

--------------------------------

### Learning and Adaptation Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code examples illustrating learning and adaptation in AI agents. These snippets show how agents can modify their behavior or knowledge based on new data or feedback.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.document_loaders import TextLoader
from langchain.chains import RetrievalQA

llm = OpenAI(temperature=0.7)
embeddings = OpenAIEmbeddings()

# Assume we have a document for initial learning
with open("doc.txt", "w") as f:
    f.write("The sky is blue. Birds can fly.")

loader = TextLoader("doc.txt")
documents = loader.load()

# Create a knowledge base (vector store)
knowledge_base = FAISS.from_documents(documents, embeddings)
retriever = knowledge_base.as_retriever()

# Create a QA chain
qa_chain = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever)

# Ask a question based on the initial knowledge
print(qa_chain.run("What color is the sky?"))

# Simulate learning new information
with open("new_doc.txt", "w") as f:
    f.write("The sun is bright. The grass is green.")

loader_new = TextLoader("new_doc.txt")
documents_new = loader_new.load()

# Update the knowledge base
new_knowledge_base = FAISS.from_documents(documents_new, embeddings)
new_retriever = new_knowledge_base.as_retriever()

# Combine retrievers (or create a new chain with updated knowledge)
# For simplicity, let's recreate the chain with the new knowledge
updated_knowledge_base = FAISS.vstack([
    knowledge_base,
    new_knowledge_base
])
updated_retriever = updated_knowledge_base.as_retriever()
updated_qa_chain = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=updated_retriever)

# Ask a question incorporating the new knowledge
print(updated_qa_chain.run("What color is the grass?"))
print(updated_qa_chain.run("Is the sun bright?"))
```

--------------------------------

### Prompt Chaining Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code examples demonstrating the concept of prompt chaining in AI agent design. These snippets illustrate how to structure prompts to create sequential or dependent AI agent behaviors.

```python
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7)

# First prompt template for generating a story idea
prompt1 = PromptTemplate(
    input_variables=["topic"],
    template="Give me a creative story idea about {topic}."
)

# Chain to generate the story idea
chain1 = LLMChain(llm=llm, prompt=prompt1)

# Second prompt template for expanding on the idea
prompt2 = PromptTemplate(
    input_variables=["idea"],
    template="Expand on this story idea: {idea}"
)

# Chain to expand the story idea
chain2 = LLMChain(llm=llm, prompt=prompt2)

# Running the chains sequentially
story_idea = chain1.run("AI in space")
full_story = chain2.run(story_idea)

print("Story Idea:", story_idea)
print("Full Story:", full_story)
```

--------------------------------

### Memory Management Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets demonstrating memory management techniques for AI agents. These examples show how agents can maintain and utilize conversation history or state.

```python
from langchain.llms import OpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

llm = OpenAI(temperature=0)

# Initialize memory
memory = ConversationBufferMemory()

# Initialize conversation chain with memory
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# Interact with the conversation
print(conversation.predict(input="Hi, my name is Bob."))
print(conversation.predict(input="What is my name?"))
print(conversation.predict(input="What was the previous question I asked?"))

# Print the final memory state
print("\nFinal Memory:\n", memory.buffer)
```

--------------------------------

### Tool Use Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets demonstrating how AI agents can use external tools. These examples show the integration and invocation of tools (e.g., search engines, calculators) to augment agent capabilities.

```python
from langchain.agents import AgentType, initialize_agent, load_tools
from langchain.llms import OpenAI

# Initialize the LLM
llm = OpenAI(temperature=0)

# Load tools (e.g., Search and Calculator)
tools = load_tools(["serpapi", "llm-math"], llm=llm)

# Initialize the agent
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

# Run the agent with a query that requires tools
agent.run("What is the weather in San Francisco? What is 2 + 2?")
```

--------------------------------

### Parallelization Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code examples demonstrating parallel execution of tasks for AI agents. These snippets show how to run multiple agent operations concurrently to improve efficiency and speed.

```python
import asyncio
from langchain.llms import OpenAI

async def process_task(task_description):
    llm = OpenAI(temperature=0.7)
    prompt = f"Process the following task: {task_description}"
    response = await llm.agenerate([prompt])
    return f"Result for '{task_description}': {response.generations[0][0].text}"

async def main():
    tasks = [
        process_task("Summarize document A"),
        process_task("Translate document B to French"),
        process_task("Analyze sentiment of document C")
    ]
    results = await asyncio.gather(*tasks)
    for result in results:
        print(result)

if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Exception Handling and Recovery Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets illustrating exception handling and recovery mechanisms for AI agents. These examples show how agents can manage errors and attempt to recover from failures.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7)

# Simulate a task that might fail
def potentially_failing_task(input_data):
    if "error" in input_data.lower():
        raise ValueError("Simulated processing error")
    return f"Successfully processed: {input_data}"

# Prompt for generating a response or recovery strategy
response_prompt = PromptTemplate(
    input_variables=["task_input", "error_message"],
    template="Task input was: '{task_input}'. An error occurred: '{error_message}'. Suggest a recovery strategy or provide a best-effort response."
)
response_chain = LLMChain(llm=llm, prompt=response_prompt)

task_input_success = "Process data normally"
task_input_fail = "Process data with error"

try:
    result = potentially_failing_task(task_input_success)
    print(f"Success: {result}")
except Exception as e:
    print(f"Caught exception: {e}")
    recovery_response = response_chain.run(task_input=task_input_success, error_message=str(e))
    print(f"Recovery Response: {recovery_response}")

try:
    result = potentially_failing_task(task_input_fail)
    print(f"Success: {result}")
except Exception as e:
    print(f"Caught exception: {e}")
    recovery_response = response_chain.run(task_input=task_input_fail, error_message=str(e))
    print(f"Recovery Response: {recovery_response}")
```

--------------------------------

### Resource-Aware Optimization Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets demonstrating resource-aware optimization for AI agents. These examples show how agents can make decisions considering resource constraints like cost, latency, or computational power.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7)

# Example: Choosing between a cheaper but slower model vs. expensive but faster model
def get_cheaper_model_response(query):
    # Simulate calling a cheaper, slower LLM
    return f"(Cheaper Model) Response to '{query}'"

def get_expensive_model_response(query):
    # Simulate calling an expensive, faster LLM
    return f"(Expensive Model) Response to '{query}'"

# Prompt to decide which resource strategy to use
strategy_prompt = PromptTemplate(
    input_variables=["query", "constraints"],
    template="Given the query \"{query}\" and constraints \"{constraints}\", which resource strategy is best? (e.g., 'cheap', 'fast', 'balanced')"
)
strategy_chain = LLMChain(llm=llm, prompt=strategy_prompt)

query = "Summarize this long document."
constraints = "Low cost, latency is acceptable."

strategy = strategy_chain.run(query=query, constraints=constraints)

if "cheap" in strategy.lower():
    response = get_cheaper_model_response(query)
elif "fast" in strategy.lower():
    response = get_expensive_model_response(query)
else: # Balanced or default
    response = get_cheaper_model_response(query) # Defaulting to cheaper model

print(f"Query: {query}\nConstraints: {constraints}\nSelected Strategy: {strategy}\nResponse: {response}")
```

--------------------------------

### Inter-Agent Communication (A2A) Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets illustrating inter-agent communication (A2A) patterns. These examples show how different AI agents can exchange messages and coordinate their actions.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7)

# Agent 1: Generates a request
agent1_prompt = PromptTemplate(
    input_variables=["topic"],
    template="Agent 1: Generate a request to Agent 2 about {topic}. Request:"
)
agent1_chain = LLMChain(llm=llm, prompt=agent1_prompt)

# Agent 2: Responds to a request
agent2_prompt = PromptTemplate(
    input_variables=["request"],
    template="Agent 2: Received request: \"{request}\". Provide a relevant response. Response:"
)
agent2_chain = LLMChain(llm=llm, prompt=agent2_prompt)

# Simulate communication flow
topic = "weather data"
request_to_agent2 = agent1_chain.run(topic)
print(request_to_agent2)

response_from_agent2 = agent2_chain.run(request_to_agent2)
print(response_from_agent2)

# Optionally, Agent 1 could process Agent 2's response
agent1_process_prompt = PromptTemplate(
    input_variables=["response"],
    template="Agent 1: Processed response from Agent 2: \"{response}\". Action:"
)
agent1_process_chain = LLMChain(llm=llm, prompt=agent1_process_prompt)

action_based_on_response = agent1_process_chain.run(response_from_agent2)
print(action_based_on_response)
```

--------------------------------

### Reasoning Techniques Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets illustrating various reasoning techniques used by AI agents. These examples cover logical deduction, causal reasoning, and analogical reasoning.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7)

# Example: Chain-of-Thought (CoT) reasoning
cot_prompt = PromptTemplate(
    input_variables=["question"],
    template="Question: {question}\nLet's think step by step."
)
cot_chain = LLMChain(llm=llm, prompt=cot_prompt)

question = "If a train leaves station A at 10:00 AM traveling at 60 mph, and station B is 120 miles away, what time does it arrive at station B?"

reasoning_output = cot_chain.run(question)
print(f"Question: {question}\nReasoning:\n{reasoning_output}")

# Example: Analogy-based reasoning
analogy_prompt = PromptTemplate(
    input_variables=["item1", "item2", "item3"],
    template="{item1} is to {item2} as {item3} is to what?"
)
anology_chain = LLMChain(llm=llm, prompt=analogy_prompt)

analogy_result = analogy_prompt.format(item1="Dog", item2="Puppy", item3="Cat")
analogy_answer = llm.invoke(analogy_result) # Direct LLM call for simpler analogy

print(f"\nAnalogy: {analogy_result}\nAnswer: {analogy_answer}")
```

--------------------------------

### Model Context Protocol (MCP) Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets illustrating the Model Context Protocol (MCP) for AI agents. These examples show how context is managed and communicated between different parts of an agent or system.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7)

# Define a context-aware prompt template
context_prompt = PromptTemplate(
    input_variables=["context", "query"],
    template="Based on the following context:\n{context}\n\nAnswer the query: {query}"
)
context_chain = LLMChain(llm=llm, prompt=context_prompt)

# Initial context and query
initial_context = "The weather today is sunny with a high of 75 degrees Fahrenheit."
query = "What is the temperature today?"

response = context_chain.run(context=initial_context, query=query)
print(f"Query: {query}\nResponse: {response}\n")

# Update context and re-query
updated_context = initial_context + " There might be a chance of rain tomorrow."
query_tomorrow = "Will it rain tomorrow?"

response_tomorrow = context_chain.run(context=updated_context, query=query_tomorrow)
print(f"Query: {query_tomorrow}\nResponse: {response_tomorrow}")
```

--------------------------------

### Knowledge Retrieval (RAG) Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets demonstrating Retrieval-Augmented Generation (RAG) for AI agents. These examples show how agents retrieve relevant information from a knowledge base before generating a response.

```python
from langchain.llms import OpenAI
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.document_loaders import TextLoader
from langchain.chains import RetrievalQA

llm = OpenAI(temperature=0.7)
embeddings = OpenAIEmbeddings()

# Create dummy documents
with open("knowledge_base.txt", "w") as f:
    f.write("LangChain is a framework for developing applications powered by language models.\n")
    f.write("Vector stores are databases optimized for storing and querying vector embeddings.\n")

loader = TextLoader("knowledge_base.txt")
documents = loader.load()

# Create a vector store from the documents
vector_store = FAISS.from_documents(documents, embeddings)
retriever = vector_store.as_retriever()

# Create a RetrievalQA chain
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True
)

# Ask a question that requires retrieving information
query = "What is LangChain?"
result = qa_chain.invoke(query)

print(f"Query: {query}")
print(f"Result: {result['result']}\n")

print("Source Documents:")
for doc in result['source_documents']:
    print(f"- {doc.page_content}\n")
```

--------------------------------

### Guardrails/Safety Patterns Code Examples

Source: https://docs.google.com/document/d/document/u/0/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/mobilebasic

Code snippets demonstrating guardrails and safety patterns for AI agents. These examples show how to implement constraints and safety checks to ensure responsible AI behavior.

```python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0.7
```
Tokens:
Raw