LangChain for Developer Workflows

from langchain.llms import OpenAI
from langchain.chains import LLMChain, SequentialChain
from langchain.prompts import PromptTemplate
from langchain.memory import ConversationBufferMemory

# Initialize LLM
llm = OpenAI(temperature=0.7)

# Create specialized chains
code_review_template = """
Review this code for issues:
{code}

Previous feedback: {chat_history}
Focus on: {focus_areas}

Provide specific, actionable feedback:
"""

documentation_template = """
Generate documentation for this code:
{code}

Style: {doc_style}
Include examples: {include_examples}

Documentation:
"""

code_review_prompt = PromptTemplate(
    input_variables=["code", "chat_history", "focus_areas"],
    template=code_review_template
)

doc_prompt = PromptTemplate(
    input_variables=["code", "doc_style", "include_examples"],
    template=documentation_template
)

# Create chains with memory
memory = ConversationBufferMemory(memory_key="chat_history")

review_chain = LLMChain(
    llm=llm,
    prompt=code_review_prompt,
    memory=memory,
    verbose=True
)

doc_chain = LLMChain(
    llm=llm,
    prompt=doc_prompt,
    verbose=True
)

# Create a sequential chain for full code processing
full_workflow = SequentialChain(
    chains=[review_chain, doc_chain],
    input_variables=["code", "focus_areas", "doc_style", "include_examples"],
    output_variables=["review_result", "documentation"],
    verbose=True
)

# Execute workflow
result = full_workflow({
    "code": """
    def process_user_data(users):
        return [user for user in users if user.active]
    """,
    "focus_areas": "performance, error handling",
    "doc_style": "Google",
    "include_examples": "yes"
})

print("Review:", result["review_result"])
print("Docs:", result["documentation"])

from langchain.tools import BaseTool

class CodeExecutionTool(BaseTool):
    name = "code_execution"
    description = "Execute Python code safely"

    def _run(self, code: str) -> str:
        # Safe code execution logic
        try:
            exec_globals = {"__builtins__": {}}
            exec(code, exec_globals)
            return "Code executed successfully"
        except Exception as e:
            return f"Error: {str(e)}"

    async def _arun(self, code: str) -> str:
        return self._run(code)

# Use in agent
from langchain.agents import initialize_agent, AgentType

tools = [CodeExecutionTool()]
agent = initialize_agent(
    tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)

response = agent.run("Write and test a function to calculate fibonacci numbers")