LangGraph

pip install reminix-langgraph

from typing import TypedDict
from langgraph.graph import StateGraph, END
from reminix_langgraph import serve_agent

# Define your graph
class AgentState(TypedDict):
    messages: list
    next_step: str

def process_node(state):
    # Process logic
    return {"next_step": "respond"}

def respond_node(state):
    # Response logic
    return {"messages": state["messages"] + ["Response"]}

graph = StateGraph(AgentState)
graph.add_node("process", process_node)
graph.add_node("respond", respond_node)
graph.add_edge("process", "respond")
graph.add_edge("respond", END)
graph.set_entry_point("process")

workflow = graph.compile()

# Wrap and serve
if __name__ == "__main__":
    serve_agent(workflow, name="workflow-agent", port=8080)

from langgraph.graph import StateGraph
from reminix_langgraph import wrap_agent

graph = StateGraph(MyState)
# ... define nodes and edges
workflow = graph.compile()

agent = wrap_agent(workflow, name="my-workflow")

from langgraph.checkpoint.memory import MemorySaver
from reminix_langgraph import wrap_agent

checkpointer = MemorySaver()
workflow = graph.compile(checkpointer=checkpointer)

agent = wrap_agent(
    workflow,
    name="stateful-workflow",
    checkpointer=checkpointer
)

from langgraph.prebuilt import create_react_agent
from reminix_langgraph import wrap_agent

agent = create_react_agent(llm, tools)
reminix_agent = wrap_agent(agent, name="react-agent")

agent = wrap_agent(
    workflow,
    name="my-workflow",
    description="Multi-step processing workflow",

    # State mapping
    input_key="messages",
    output_key="messages",

    # Streaming
    streaming=True,
    stream_mode="updates"  # "values" or "updates"
)

from reminix_langgraph import wrap_agent
from reminix_runtime import serve

workflow1 = wrap_agent(graph1.compile(), name="research-workflow")
workflow2 = wrap_agent(graph2.compile(), name="writing-workflow")

serve(agents=[workflow1, workflow2], port=8080)

def map_input(reminix_input: dict) -> AgentState:
    return {
        "messages": [{"role": "user", "content": reminix_input["query"]}],
        "context": reminix_input.get("context", {})
    }

agent = wrap_agent(
    workflow,
    name="my-workflow",
    input_mapper=map_input
)

def map_output(state: AgentState) -> dict:
    return {
        "response": state["messages"][-1]["content"],
        "steps": len(state["messages"])
    }

agent = wrap_agent(
    workflow,
    name="my-workflow",
    output_mapper=map_output
)

from reminix import Reminix

client = Reminix()

for chunk in client.agents.invoke(
    "workflow-agent",
    messages=[{"role": "user", "content": "Process this"}],
    stream=True
):
    print(chunk, end="", flush=True)

from typing import TypedDict
from langgraph.graph import StateGraph, END
from reminix_langgraph import wrap_agent
from reminix_runtime import serve

class ResearchState(TypedDict):
    query: str
    search_results: list
    analysis: str
    summary: str

def search(state):
    results = web_search(state["query"])
    return {"search_results": results}

def analyze(state):
    analysis = analyze_results(state["search_results"])
    return {"analysis": analysis}

def summarize(state):
    summary = create_summary(state["analysis"])
    return {"summary": summary}

graph = StateGraph(ResearchState)
graph.add_node("search", search)
graph.add_node("analyze", analyze)
graph.add_node("summarize", summarize)
graph.add_edge("search", "analyze")
graph.add_edge("analyze", "summarize")
graph.add_edge("summarize", END)
graph.set_entry_point("search")

workflow = graph.compile()
agent = wrap_agent(workflow, name="research-agent")

if __name__ == "__main__":
    serve(agents=[agent], port=8080)

from reminix import Reminix

client = Reminix()

response = client.agents.invoke(
    "workflow-agent",
    messages=[{"role": "user", "content": "Research AI trends"}]
)

print(response.output)

response = client.agents.invoke(
    "research-agent",
    query="Research AI trends in healthcare"
)

print(response.output)

for chunk in client.agents.invoke(
    "workflow-agent",
    messages=[{"role": "user", "content": "Research AI trends"}],
    stream=True
):
    print(chunk, end="", flush=True)