hyperforge-perplexity 1.0.0.post22__py3-none-any.whl

hyperforge_perplexity/__init__.py

@@ -0,0 +1,4 @@
+from .driver import PerplexityDriver
+from .perplexity import PerplexityAgent
+
+__all__ = ["PerplexityAgent", "PerplexityDriver"]

hyperforge_perplexity/config.py

@@ -0,0 +1,64 @@
+from typing import ClassVar, List, Literal, Optional, Tuple
+
+from hyperforge.context.config import ContextAgentConfig
+from hyperforge.driver import DriverConfig, EncryptedPayload
+from hyperforge.utils import WidgetType
+from pydantic import Field
+from pydantic.config import ConfigDict
+
+
+class PerplexityInnerConfig(EncryptedPayload):
+    encrypted_fields: ClassVar[list[str]] = ["key"]
+    key: str
+
+
+class PerplexityDriverConfig(DriverConfig[PerplexityInnerConfig]):
+    model_config = ConfigDict(title="Perplexity")
+    provider: Literal["perplexity"]
+    config: PerplexityInnerConfig
+
+
+class PerplexityAgentConfig(ContextAgentConfig):
+    model_config = ConfigDict(title="Perplexity Answer")
+    module: Literal["perplexity"] = "perplexity"
+    published_functions: Optional[Tuple[str, ...]] = Field(
+        default=("internet_search",),
+        title="Published functions",
+        description="List of functions published by this agent to be used by other agents in the chain",
+        json_schema_extra={
+            "widget": WidgetType.NOT_SHOWN,
+        },
+    )
+    domain: List[str] = Field(
+        default_factory=list,
+        title="Domain Filter",
+        description="Domains to restrict the Perplexity search to.",
+    )
+    search_context_size: Literal["low", "medium", "high"] = Field(
+        default="low",
+        title="Search Context Size",
+        description="Determines how much search context Perplexity retrieves for the model. "
+        "Options are: `low` (minimizes context for cost savings but less comprehensive answers), "
+        "`medium` (balanced approach suitable for most queries), "
+        "and `high` (maximizes context for comprehensive answers but at higher cost).",
+    )
+    related_questions: bool = Field(
+        default=False,
+        title="Generate Related Questions",
+        description="Determines if Perplexity should return related questions to the original. "
+        "They will be stored in the Agentic Memory as future questions",
+    )
+    images: bool = Field(
+        default=False,
+        title="Return Images",
+        description="Determines whether Perplexity search results should include images.",
+    )
+    prompt: Optional[str] = Field(
+        None,
+        title="Custom Prompt",
+        description="Custom prompt to use for the Perplexity agent.",
+        json_schema_extra={
+            "widget": WidgetType.EXPANDABLE_TEXTAREA,
+        },
+    )
+    source: str = "perplexity"

hyperforge_perplexity/driver.py

@@ -0,0 +1,27 @@
+from hyperforge.configure import driver
+from hyperforge.driver import Driver
+from perplexity import AsyncPerplexity
+
+from hyperforge_perplexity.config import PerplexityDriverConfig
+
+
+@driver(
+    id="perplexity",
+    title="Perplexity Driver",
+    description="Driver for interacting with the Perplexity API.",
+    config_schema=PerplexityDriverConfig,
+)
+class PerplexityDriver(Driver):
+    client: AsyncPerplexity
+    api_key: str
+
+    @classmethod
+    async def init(cls, driver: PerplexityDriverConfig):
+        client = AsyncPerplexity(api_key=driver.config.key)
+
+        return cls(
+            api_key=driver.config.key,
+            client=client,
+            name=driver.name,
+            provider=driver.provider,
+        )

hyperforge_perplexity/perplexity.py

@@ -0,0 +1,197 @@
+from base64 import b64encode
+from time import time
+from typing import Any, ClassVar, Dict, List, Optional, cast
+from uuid import uuid4
+
+from hyperforge.agent import Agent
+from hyperforge.configure import agent
+from hyperforge.context.agent import ContextAgent
+from hyperforge.definition import FunctionDefinition
+from hyperforge.manager import Manager
+from hyperforge.memory import Chunk, Context, QuestionMemory
+from hyperforge.utils.http import safe_http_client
+from nuclia.lib.nua_responses import Image
+from perplexity.types import ChatMessageInput
+from perplexity.types.shared.chat_message_output import ChatMessageOutput
+from perplexity.types.shared_params.web_search_options import WebSearchOptions
+
+from hyperforge_perplexity.config import PerplexityAgentConfig
+from hyperforge_perplexity.driver import PerplexityDriver
+
+SYSTEM_PROMPT = "Be precise and concise"
+
+
+@agent(
+    id="perplexity",
+    agent_type="context",
+    title="Perplexity Answers",
+    description="Use Perplexity to get information from the internet.",
+    config_schema=PerplexityAgentConfig,
+)
+class PerplexityAgent(ContextAgent, Agent[PerplexityAgentConfig]):
+    driver: Optional[PerplexityDriver] = None
+    __published_functions__: ClassVar[Dict[str, FunctionDefinition]] = {
+        "internet_search": FunctionDefinition(
+            name="internet_search",
+            description="Performs an internet search using Perplexity Search to get context to answer questions.",
+            parameters={
+                "question": {
+                    "type": "string",
+                    "description": "The question to search for on the internet.",
+                },
+            },
+        )
+    }
+
+    def build_messages(self, question: str) -> list:
+        """Builds the messages list for the chat completion."""
+        system_prompt = (
+            self.config.prompt if self.config.prompt is not None else SYSTEM_PROMPT
+        )
+        return [
+            ChatMessageInput(role="system", content=system_prompt),
+            ChatMessageInput(role="user", content=question),
+        ]
+
+    async def internet_search(
+        self,
+        question: str,
+        memory: QuestionMemory,
+        manager: Manager,
+        question_uuid: Optional[str] = None,
+    ) -> Context:
+        messages = self.build_messages(question)
+
+        t0 = time()
+
+        if self.driver is None:
+            self.driver: Optional[PerplexityDriver] = cast(
+                Optional[PerplexityDriver], manager.drivers.get(self.config.source)
+            )
+        if self.driver is None:
+            raise Exception("Perplexity driver does not exist")
+
+        web_search_options = WebSearchOptions(
+            search_context_size=self.config.search_context_size,
+        )
+        response = await self.driver.client.chat.completions.create(
+            messages=messages,
+            model="sonar-pro",
+            return_images=self.config.images,
+            return_related_questions=self.config.related_questions,
+            search_domain_filter=self.config.domain,
+            web_search_options=web_search_options,
+        )
+        context = Context(
+            agent_id=self.agent_id,
+            original_question_uuid=memory.original_question_uuid,
+            actual_question_uuid=question_uuid,
+            question=question,
+            title=self.config.title
+            if self.config.title
+            else "Internet search with Perplexity",
+            source="perplexity",
+            agent=self.config.module,
+        )
+        text = None
+        for choice in response.choices:
+            if (
+                choice.message is not None
+                and choice.message.content is not None
+                and isinstance(choice.message, ChatMessageOutput)
+            ):
+                text = (
+                    choice.message.content
+                    if isinstance(choice.message.content, str)
+                    else str(choice.message.content)
+                )
+
+        if (
+            hasattr(response, "images")
+            and response.images is not None
+            and isinstance(response.images, list)
+        ):
+            for image in response.images:
+                image_dict = cast(Dict[str, Any], image)
+                async with safe_http_client() as session:
+                    resp = await session.get(image_dict["image_url"])
+                content_type = resp.headers.get("Content-Type")
+                if content_type:
+                    # Remove parameters like "; charset=utf-8"
+                    mime = content_type.split(";", 1)[0].strip()
+                    if mime:
+                        context.images[image_dict["origin_url"]] = Image(
+                            content_type=mime,
+                            b64encoded=b64encode(resp.content).decode(),
+                        )
+
+        if text is not None:
+            chunk = Chunk(
+                chunk_id=uuid4().hex,
+                text=text,
+                labels=[],
+                url=response.citations,  # type: ignore
+                origin_agent=self.config.module,
+            )
+            context.chunks.append(chunk)
+
+        # for chunk in response add to context
+        input_nuclia_tokens = 0
+        context.summary = text if text is not None else ""
+
+        if (
+            self.config.related_questions
+            and hasattr(response, "related_questions")
+            and response.related_questions is not None
+        ):
+            questions: List[str] = cast(List[str], response.related_questions)
+            memory.add_future_questions(questions)
+
+        # TODO: Report nuclia tokens correctly
+        if response.usage is not None and response.usage.total_tokens is not None:
+            input_nuclia_tokens += response.usage.total_tokens
+
+        await memory.add_step(
+            step_module=self.config.module,
+            step_title=self.step_title("Search results"),
+            step_reason="",
+            step_agent_path=f"/context/{self.config.id or self.agent_id}",
+            step_value=text if text is not None else "",
+            timeit=time() - t0,
+            input_nuclia_tokens=input_nuclia_tokens,
+            output_nuclia_tokens=0,
+        )
+        return context
+
+    async def _get_question_context(
+        self,
+        memory: QuestionMemory,
+        manager: Manager,
+        question_uuid: str,
+        question: str,
+        flow_id: str,
+        extra_context: Optional[Dict[str, Any]] = None,
+    ) -> List[tuple[str, str]]:
+        if self.driver is None:
+            self.driver: Optional[PerplexityDriver] = cast(
+                Optional[PerplexityDriver], manager.drivers.get(self.config.source)
+            )
+
+        if self.driver is None:
+            raise Exception("Perplexity driver does not exist")
+
+        context = await self.internet_search(
+            question,
+            memory,
+            manager,
+            question_uuid=question_uuid,
+        )
+
+        missing = await self.save_ctx_and_return_missing(
+            context=context,
+            question=question,
+            memory=memory,
+            manager=manager,
+            flow_id=flow_id,
+        )
+        return [missing] if missing is not None else []

hyperforge_perplexity-1.0.0.post22.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: hyperforge_perplexity
+Version: 1.0.0.post22
+Summary: Perplexity Hyperforge agent
+Author-email: Nuclia <nucliadb@nuclia.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://progress.com
+Project-URL: Repository, https://github.com/nuclia/hyperforge
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <4,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: hyperforge
+Requires-Dist: httpx
+Requires-Dist: perplexityai>=0.35.1
+
+# Perplexity Hyperforge agents

hyperforge_perplexity-1.0.0.post22.dist-info/RECORD

@@ -0,0 +1,9 @@
+hyperforge_perplexity/__init__.py,sha256=1NLnfxhRQBKSXNarJGUtJUqbdxC6sYZaoqMZxOohsF0,128
+hyperforge_perplexity/config.py,sha256=ooOknxzeWTVOIyOpnmHUnkn8cwbFxAkPh2U72R3p0Ic,2459
+hyperforge_perplexity/driver.py,sha256=bHQry9SYskDbgKHi_OMwaKAPKVXe1ySWQJjSJI-vRbA,732
+hyperforge_perplexity/perplexity.py,sha256=BqdtAkzCwfrqyjPQ9wtYJH9CuV8_weR-Kr46KksjHxM,7220
+hyperforge_perplexity/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperforge_perplexity-1.0.0.post22.dist-info/METADATA,sha256=zICmj1ff2p3V0sTOZQ60M245dN0JiL5M_PVMqE8_UPc,796
+hyperforge_perplexity-1.0.0.post22.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+hyperforge_perplexity-1.0.0.post22.dist-info/top_level.txt,sha256=930QZHtq_vfVXK6qol86FhpLVYJRUmtsQoDf58OZKyQ,22
+hyperforge_perplexity-1.0.0.post22.dist-info/RECORD,,

hyperforge_perplexity-1.0.0.post22.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hyperforge_perplexity-1.0.0.post22.dist-info/top_level.txt

@@ -0,0 +1 @@
+hyperforge_perplexity