quraite 0.1.2__tar.gz → 0.1.4__tar.gz

{quraite-0.1.2 → quraite-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: quraite
-Version: 0.1.2
+Version: 0.1.4
 Summary: This project provides adaptors and methods to integrate with the Quraite platform
 Author: Shiv Mohith
 Author-email: Shiv Mohith <shivmohith8@gmail.com>
@@ -92,55 +92,43 @@ pip install 'quraite[langchain,pydantic-ai,agno]'
 Pass your compiled LangChain agent to the adapter and expose it as an HTTP API:
 
 ```python
-import asyncio
-import uvicorn
 from dotenv import load_dotenv
-from openinference.instrumentation import TracerProvider
-from openinference.instrumentation.langchain import LangChainInstrumentor
 
-from quraite.adapters import LangChainAdapter
-from quraite.serve.local_agent import LocalAgentServer
-from quraite.tracing.span_exporter import QuraiteInMemorySpanExporter
-from quraite.tracing.span_processor import QuraiteSimpleSpanProcessor
+from quraite import run_agent
+from quraite.adapters import LangchainAdapter
+from quraite.tracing import Framework, setup_tracing
 
 load_dotenv()
 
-# Set up tracing
-# Use Quraite's in-memory span exporter to capture the agent trajectory
-# and use it for evaluation.
-tracer_provider = TracerProvider()
-quraite_span_exporter = QuraiteInMemorySpanExporter()
-quraite_span_processor = QuraiteSimpleSpanProcessor(quraite_span_exporter)
-tracer_provider.add_span_processor(quraite_span_processor)
-LangChainInstrumentor().instrument(tracer_provider=tracer_provider)
-
 # Your compiled LangChain agent (created elsewhere)
 # agent = create_agent(...)
 
-# Wrap with Quraite adapter
-adapter = LangChainAdapter(
+# Setup tracing once
+tracer_provider = setup_tracing([Framework.LANGCHAIN])
+
+# Create adapter with tracer provider
+adapter = LangchainAdapter(
     agent_graph=agent,  # Pass your compiled LangChain agent here
     tracer_provider=tracer_provider,
 )
 
-# Create and start server with Cloudflare tunnel
-server = LocalAgentServer(
-    wrapped_agent=adapter,
+# Option 1: Use run_agent to start the server (simplest)
+run_agent(
+    adapter,
     agent_id="your-agent-id",  # Optional: for Quraite platform integration
-)
-
-app = server.create_app(
     port=8080,
     host="0.0.0.0",
     tunnel="cloudflare",  # Options: "cloudflare", "ngrok", or "none"
 )
 
-# Option 1: Use the start method to start the server
-asyncio.run(server.start(host="0.0.0.0", port=8080))
+# Option 2: Use create_app for more control (e.g., with uvicorn reload)
+from quraite import create_app
+import uvicorn
+
+app = create_app(adapter, agent_id="your-agent-id")
 
-# Option 2: Use uvicorn to start the server for auto-reload
-# if __name__ == "__main__":
-#     uvicorn.run("local_server:app", host="0.0.0.0", port=8080, reload=True)
+if __name__ == "__main__":
+    uvicorn.run("local_server:app", host="0.0.0.0", port=8080, reload=True)
 ```
 
 The server exposes:
@@ -191,20 +179,14 @@ Most agent frameworks return agent steps, but lack critical observability data.
 To enable tracing:
 
 ```python
-from openinference.instrumentation import TracerProvider
-from quraite.tracing.span_exporter import QuraiteInMemorySpanExporter
-from quraite.tracing.span_processor import QuraiteSimpleSpanProcessor
-
-tracer_provider = TracerProvider()
+from quraite.tracing import Framework, setup_tracing
 
-# Add Quraite span exporter and processor to the tracer provider
-quraite_span_exporter = QuraiteInMemorySpanExporter()
-quraite_span_processor = QuraiteSimpleSpanProcessor(quraite_span_exporter)
-tracer_provider.add_span_processor(quraite_span_processor)
+# Setup tracing once at app startup
+tracer_provider = setup_tracing([Framework.LANGCHAIN])
 
-# Instrument your framework with OpenInference
-from openinference.instrumentation.langchain import LangChainInstrumentor
-LangChainInstrumentor().instrument(tracer_provider=tracer_provider)
+# Pass to adapter
+from quraite.adapters import LangchainAdapter
+adapter = LangchainAdapter(agent_graph=agent, tracer_provider=tracer_provider)
 ```
 
 ### Message Schema
@@ -245,16 +227,18 @@ tool_msg = ToolMessage(
 )
 ```
 
-### Response Format
+### Invoke Input and Output
 
-Agent invocations return an `AgentInvocationResponse`:
+Agent invocations use structured `InvokeInput` and return `InvokeOutput`:
 
 ```python
-from quraite.schema.response import AgentInvocationResponse
+from quraite.schema.invoke import InvokeInput, InvokeOutput
 
-response: AgentInvocationResponse = await adapter.ainvoke(
-    input=[user_msg],
-    session_id="session-123"
+response: InvokeOutput = await adapter.ainvoke(
+    input=InvokeInput(
+        user_message=user_msg,
+        session_id="session-123"
+    )
 )
 
 # Access trajectory (list of messages)
@@ -292,37 +276,45 @@ All adapters inherit from `BaseAdapter`:
 
 ```python
 from quraite.adapters.base import BaseAdapter
+from quraite.schema.invoke import InvokeInput, InvokeOutput
 
 class MyAdapter(BaseAdapter):
     async def ainvoke(
         self,
-        input: List[AgentMessage],
-        session_id: str | None,
-    ) -> AgentInvocationResponse:
+        input: InvokeInput,
+    ) -> InvokeOutput:
         # Implementation
+        # Access user_message: input.user_message
+        # Access session_id: input.session_id
         pass
 ```
 
-### LocalAgentServer
+### Running Your Agent
 
-Create a local HTTP server for your agent:
+Use `run_agent` or `create_app` to start a local HTTP server for your agent:
 
 ```python
-import asyncio
-from quraite.serve.local_agent import LocalAgentServer
+from quraite import run_agent, create_app
 
-server = LocalAgentServer(
-    wrapped_agent=adapter,
+# Simple approach: run_agent handles everything
+run_agent(
+    adapter,
     agent_id="optional-agent-id",
-)
-
-app = server.create_app(
     port=8080,
     host="0.0.0.0",
     tunnel="cloudflare",  # or "ngrok" or "none"
 )
 
-asyncio.run(server.start(host="0.0.0.0", port=8080))
+# Advanced approach: create_app for more control (e.g., uvicorn reload)
+import uvicorn
+
+app = create_app(
+    adapter,
+    agent_id="optional-agent-id",
+)
+
+if __name__ == "__main__":
+    uvicorn.run("local_server:app", host="0.0.0.0", port=8080, reload=True)
 ```
 
 ## Development

{quraite-0.1.2 → quraite-0.1.4}/README.md

@@ -57,55 +57,43 @@ pip install 'quraite[langchain,pydantic-ai,agno]'
 Pass your compiled LangChain agent to the adapter and expose it as an HTTP API:
 
 ```python
-import asyncio
-import uvicorn
 from dotenv import load_dotenv
-from openinference.instrumentation import TracerProvider
-from openinference.instrumentation.langchain import LangChainInstrumentor
 
-from quraite.adapters import LangChainAdapter
-from quraite.serve.local_agent import LocalAgentServer
-from quraite.tracing.span_exporter import QuraiteInMemorySpanExporter
-from quraite.tracing.span_processor import QuraiteSimpleSpanProcessor
+from quraite import run_agent
+from quraite.adapters import LangchainAdapter
+from quraite.tracing import Framework, setup_tracing
 
 load_dotenv()
 
-# Set up tracing
-# Use Quraite's in-memory span exporter to capture the agent trajectory
-# and use it for evaluation.
-tracer_provider = TracerProvider()
-quraite_span_exporter = QuraiteInMemorySpanExporter()
-quraite_span_processor = QuraiteSimpleSpanProcessor(quraite_span_exporter)
-tracer_provider.add_span_processor(quraite_span_processor)
-LangChainInstrumentor().instrument(tracer_provider=tracer_provider)
-
 # Your compiled LangChain agent (created elsewhere)
 # agent = create_agent(...)
 
-# Wrap with Quraite adapter
-adapter = LangChainAdapter(
+# Setup tracing once
+tracer_provider = setup_tracing([Framework.LANGCHAIN])
+
+# Create adapter with tracer provider
+adapter = LangchainAdapter(
     agent_graph=agent,  # Pass your compiled LangChain agent here
     tracer_provider=tracer_provider,
 )
 
-# Create and start server with Cloudflare tunnel
-server = LocalAgentServer(
-    wrapped_agent=adapter,
+# Option 1: Use run_agent to start the server (simplest)
+run_agent(
+    adapter,
     agent_id="your-agent-id",  # Optional: for Quraite platform integration
-)
-
-app = server.create_app(
     port=8080,
     host="0.0.0.0",
     tunnel="cloudflare",  # Options: "cloudflare", "ngrok", or "none"
 )
 
-# Option 1: Use the start method to start the server
-asyncio.run(server.start(host="0.0.0.0", port=8080))
+# Option 2: Use create_app for more control (e.g., with uvicorn reload)
+from quraite import create_app
+import uvicorn
+
+app = create_app(adapter, agent_id="your-agent-id")
 
-# Option 2: Use uvicorn to start the server for auto-reload
-# if __name__ == "__main__":
-#     uvicorn.run("local_server:app", host="0.0.0.0", port=8080, reload=True)
+if __name__ == "__main__":
+    uvicorn.run("local_server:app", host="0.0.0.0", port=8080, reload=True)
 ```
 
 The server exposes:
@@ -156,20 +144,14 @@ Most agent frameworks return agent steps, but lack critical observability data.
 To enable tracing:
 
 ```python
-from openinference.instrumentation import TracerProvider
-from quraite.tracing.span_exporter import QuraiteInMemorySpanExporter
-from quraite.tracing.span_processor import QuraiteSimpleSpanProcessor
-
-tracer_provider = TracerProvider()
+from quraite.tracing import Framework, setup_tracing
 
-# Add Quraite span exporter and processor to the tracer provider
-quraite_span_exporter = QuraiteInMemorySpanExporter()
-quraite_span_processor = QuraiteSimpleSpanProcessor(quraite_span_exporter)
-tracer_provider.add_span_processor(quraite_span_processor)
+# Setup tracing once at app startup
+tracer_provider = setup_tracing([Framework.LANGCHAIN])
 
-# Instrument your framework with OpenInference
-from openinference.instrumentation.langchain import LangChainInstrumentor
-LangChainInstrumentor().instrument(tracer_provider=tracer_provider)
+# Pass to adapter
+from quraite.adapters import LangchainAdapter
+adapter = LangchainAdapter(agent_graph=agent, tracer_provider=tracer_provider)
 ```
 
 ### Message Schema
@@ -210,16 +192,18 @@ tool_msg = ToolMessage(
 )
 ```
 
-### Response Format
+### Invoke Input and Output
 
-Agent invocations return an `AgentInvocationResponse`:
+Agent invocations use structured `InvokeInput` and return `InvokeOutput`:
 
 ```python
-from quraite.schema.response import AgentInvocationResponse
+from quraite.schema.invoke import InvokeInput, InvokeOutput
 
-response: AgentInvocationResponse = await adapter.ainvoke(
-    input=[user_msg],
-    session_id="session-123"
+response: InvokeOutput = await adapter.ainvoke(
+    input=InvokeInput(
+        user_message=user_msg,
+        session_id="session-123"
+    )
 )
 
 # Access trajectory (list of messages)
@@ -257,37 +241,45 @@ All adapters inherit from `BaseAdapter`:
 
 ```python
 from quraite.adapters.base import BaseAdapter
+from quraite.schema.invoke import InvokeInput, InvokeOutput
 
 class MyAdapter(BaseAdapter):
     async def ainvoke(
         self,
-        input: List[AgentMessage],
-        session_id: str | None,
-    ) -> AgentInvocationResponse:
+        input: InvokeInput,
+    ) -> InvokeOutput:
         # Implementation
+        # Access user_message: input.user_message
+        # Access session_id: input.session_id
         pass
 ```
 
-### LocalAgentServer
+### Running Your Agent
 
-Create a local HTTP server for your agent:
+Use `run_agent` or `create_app` to start a local HTTP server for your agent:
 
 ```python
-import asyncio
-from quraite.serve.local_agent import LocalAgentServer
+from quraite import run_agent, create_app
 
-server = LocalAgentServer(
-    wrapped_agent=adapter,
+# Simple approach: run_agent handles everything
+run_agent(
+    adapter,
     agent_id="optional-agent-id",
-)
-
-app = server.create_app(
     port=8080,
     host="0.0.0.0",
     tunnel="cloudflare",  # or "ngrok" or "none"
 )
 
-asyncio.run(server.start(host="0.0.0.0", port=8080))
+# Advanced approach: create_app for more control (e.g., uvicorn reload)
+import uvicorn
+
+app = create_app(
+    adapter,
+    agent_id="optional-agent-id",
+)
+
+if __name__ == "__main__":
+    uvicorn.run("local_server:app", host="0.0.0.0", port=8080, reload=True)
 ```
 
 ## Development

{quraite-0.1.2 → quraite-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quraite"
-version = "0.1.2"
+version = "0.1.4"
 description = "This project provides adaptors and methods to integrate with the Quraite platform"
 readme = "README.md"
 authors = [
@@ -49,10 +49,12 @@ module-root = ""
 
 [dependency-groups]
 dev = [
-    "autoflake>=2.3.1",
-    "black>=25.9.0",
     "ipykernel>=7.1.0",
-    "isort>=6.1.0",
+    "mypy>=1.14.1",
+    "ruff>=0.9.4",
+]
+temp = [
+    "arize-phoenix-otel>=0.14.0",
 ]
 test = [
     "numpy>=2.2.6",
@@ -72,3 +74,22 @@ test = [
     "pytest-env>=1.2.0",
     "pytest-dotenv>=0.5.2",
 ]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+ignore = []
+
+[tool.ruff.lint.isort]
+known-first-party = ["quraite"]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false
+ignore_missing_imports = true
+explicit_package_bases = true

quraite-0.1.4/quraite/__init__.py

@@ -0,0 +1,7 @@
+"""Quraite Python SDK"""
+
+from quraite.serve import create_app, run_agent, setup_tunnel
+
+__version__ = "0.6.0"
+
+__all__ = ["create_app", "run_agent", "setup_tunnel"]

quraite-0.1.4/quraite/adapters/agno_adapter.py

@@ -0,0 +1,115 @@
+import uuid
+
+from agno.agent import Agent
+from agno.team import Team
+from openinference.instrumentation.agno.utils import _AGNO_PARENT_NODE_CONTEXT_KEY
+from opentelemetry import context as context_api
+from opentelemetry.trace import TracerProvider
+
+from quraite.adapters.base import BaseAdapter
+from quraite.constants.framework import Framework
+from quraite.logger import get_logger
+from quraite.schema.invoke import InvokeInput, InvokeOutput
+from quraite.tracing.trace import AgentSpan, AgentTrace
+
+logger = get_logger(__name__)
+
+
+class AgnoAdapter(BaseAdapter):
+    """Agno adapter for Agent and Team (requires tracing)."""
+
+    def __init__(
+        self,
+        agent: Agent | Team,
+        *,
+        tracer_provider: TracerProvider | None = None,
+        agent_name: str = "Agno Agent",
+    ):
+        """
+        Initialize Agno adapter.
+
+        Args:
+            agent: Agno Agent or Team instance
+            tracer_provider: TracerProvider from setup_tracing() (required)
+            agent_name: Agent name for metadata
+        """
+        if tracer_provider is None:
+            raise ValueError(
+                "Agno adapter requires tracing. Use setup_tracing([Framework.AGNO]) first."
+            )
+
+        self.agent: Agent | Team = agent
+        self.agent_name = agent_name
+        self._init_tracer(tracer_provider)
+        logger.info("AgnoAdapter initialized")
+
+    async def ainvoke(self, input: InvokeInput) -> InvokeOutput:
+        """Invoke Agno agent and return response with trace."""
+        logger.info("ainvoke called (session_id=%s)", input.session_id)
+        session_id = input.session_id or str(uuid.uuid4())
+
+        try:
+            return await self._ainvoke_with_tracing(
+                input.user_message_str(), session_id
+            )
+        except Exception as e:
+            logger.exception("Error invoking Agno agent")
+            raise RuntimeError(f"Error invoking Agno agent: {e}") from e
+
+    async def _ainvoke_with_tracing(
+        self,
+        user_message: str,
+        session_id: str,
+    ) -> InvokeOutput:
+        """Execute ainvoke with tracing enabled."""
+        with self.tracer.start_as_current_span("agno_invocation") as span:
+            # Workaround: openinference-instrumentation-agno>=0.1.25 forces a new root
+            # trace for Team instances unless _AGNO_PARENT_NODE_CONTEXT_KEY is set.
+            # This ensures child spans inherit our trace_id.
+            # See: https://github.com/Arize-ai/openinference/pull/2533
+            #
+            # Context API notes:
+            # - set_value() creates a new Context with the key-value pair (doesn't activate it)
+            # - attach() makes the context active and returns a token (restore point)
+            # - detach(token) restores the previous context (cleanup)
+            ctx = context_api.set_value(
+                _AGNO_PARENT_NODE_CONTEXT_KEY,
+                format(span.get_span_context().span_id, '016x')
+            )
+            token = context_api.attach(ctx)
+            trace_id = span.get_span_context().trace_id
+
+            logger.debug(
+                "Starting traced invocation (session_id=%s) with trace_id=%s",
+                session_id,
+                trace_id,
+            )
+            try:
+                await self.agent.arun(user_message, session_id=session_id)
+            finally:
+                context_api.detach(token)
+
+        # Get trace spans
+        trace_readable_spans = self.quraite_span_exporter.get_spans_by_trace_id(
+            trace_id
+        )
+
+        if trace_readable_spans:
+            logger.info(
+                "Retrieved %d spans for trace_id=%s",
+                len(trace_readable_spans),
+                trace_id,
+            )
+            agent_trace = AgentTrace(
+                spans=[
+                    AgentSpan.from_readable_oi_span(span)
+                    for span in trace_readable_spans
+                ],
+            )
+        else:
+            logger.warning("No spans found for trace_id=%s", trace_id)
+
+        return InvokeOutput(
+            agent_trace=agent_trace,
+            agent_trajectory=agent_trace.to_agent_trajectory(framework=Framework.AGNO),
+        )

quraite-0.1.4/quraite/adapters/base.py

@@ -0,0 +1,73 @@
+from abc import ABC, abstractmethod
+
+from opentelemetry.sdk.trace import TracerProvider as SDKTracerProvider
+from opentelemetry.trace import Tracer, TracerProvider
+
+from quraite.logger import get_logger
+from quraite.schema.invoke import InvokeInput, InvokeOutput
+from quraite.schema.message import AssistantMessage, MessageContentText
+from quraite.tracing.constants import QURAITE_TRACER_NAME
+from quraite.tracing.span_exporter import QuraiteSpanExporter
+from quraite.tracing.span_processor import QuraiteSpanProcessor
+
+logger = get_logger(__name__)
+
+
+class BaseAdapter(ABC):
+    """Base adapter for all framework adapters."""
+
+    tracer_provider: TracerProvider | None = None
+    tracer: Tracer | None = None
+    quraite_span_exporter: QuraiteSpanExporter = QuraiteSpanExporter()
+
+    def _init_tracer(self, tracer_provider: SDKTracerProvider | None) -> None:
+        """Initialize tracer components from TracerProvider."""
+        if tracer_provider is None:
+            return
+
+        self.tracer_provider = tracer_provider
+        self.tracer = tracer_provider.get_tracer(QURAITE_TRACER_NAME)
+
+        # Find Quraite span exporter
+        quraite_span_exporter = next(
+            (
+                processor.span_exporter
+                for processor in tracer_provider._active_span_processor._span_processors
+                if isinstance(processor, QuraiteSpanProcessor)
+            ),
+            None,
+        )
+
+        if quraite_span_exporter is None:
+            raise ValueError(
+                "Quraite span exporter not found. "
+                "Use setup_tracing() to configure tracing properly."
+            )
+
+        self.quraite_span_exporter = quraite_span_exporter
+
+    @abstractmethod
+    async def ainvoke(
+        self,
+        input: InvokeInput,
+    ) -> InvokeOutput:
+        """Invoke agent with input and return response."""
+        raise NotImplementedError("Not implemented")
+
+
+class DummyAdapter(BaseAdapter):
+    """Dummy adapter for testing."""
+
+    async def ainvoke(
+        self,
+        input: InvokeInput,
+    ) -> InvokeOutput:
+        """Returns dummy response."""
+        return InvokeOutput(
+            agent_trajectory=[
+                input.user_message,
+                AssistantMessage(
+                    content=[MessageContentText(text="Dummy response")],
+                ),
+            ]
+        )