pixie-examples 0.1.1.dev3__py3-none-any.whl

examples/sql_utils.py

@@ -0,0 +1,241 @@
+"""
+Lightweight SQL Database Utilities
+
+Drop-in replacements for langchain_community.utilities.SQLDatabase and
+langchain_community.agent_toolkits.SQLDatabaseToolkit without the heavy dependencies.
+
+Built on top of SQLAlchemy for database interaction.
+"""
+
+from typing import Any, Optional
+from sqlalchemy import create_engine, inspect, text, MetaData
+from sqlalchemy.engine import Engine
+
+
+class SQLDatabase:
+    """Lightweight SQLAlchemy database wrapper."""
+
+    def __init__(
+        self,
+        engine: Engine,
+        schema: Optional[str] = None,
+        include_tables: Optional[list[str]] = None,
+        ignore_tables: Optional[list[str]] = None,
+        sample_rows_in_table_info: int = 3,
+    ):
+        """Initialize SQLDatabase wrapper.
+
+        Args:
+            engine: SQLAlchemy engine
+            schema: Optional schema name
+            include_tables: Optional list of tables to include
+            ignore_tables: Optional list of tables to ignore
+            sample_rows_in_table_info: Number of sample rows to include in table info
+        """
+        self._engine = engine
+        self._schema = schema
+        self._include_tables = include_tables
+        self._ignore_tables = ignore_tables or []
+        self._sample_rows_in_table_info = sample_rows_in_table_info
+        self._metadata = MetaData()
+
+    @classmethod
+    def from_uri(
+        cls,
+        database_uri: str,
+        engine_args: Optional[dict] = None,
+        **kwargs: Any,
+    ) -> "SQLDatabase":
+        """Create SQLDatabase from a database URI.
+
+        Args:
+            database_uri: Database connection URI (e.g., 'sqlite:///path/to/db.db')
+            engine_args: Optional arguments to pass to create_engine
+            **kwargs: Additional arguments for SQLDatabase initialization
+
+        Returns:
+            SQLDatabase instance
+        """
+        engine_args = engine_args or {}
+        engine = create_engine(database_uri, **engine_args)
+        return cls(engine, **kwargs)
+
+    @property
+    def dialect(self) -> str:
+        """Get database dialect name."""
+        return self._engine.dialect.name
+
+    def get_usable_table_names(self) -> list[str]:
+        """Get list of usable table names.
+
+        Returns:
+            List of table names
+        """
+        inspector = inspect(self._engine)
+        all_tables = inspector.get_table_names(schema=self._schema)
+
+        # Filter tables
+        if self._include_tables:
+            tables = [t for t in all_tables if t in self._include_tables]
+        else:
+            tables = [t for t in all_tables if t not in self._ignore_tables]
+
+        return tables
+
+    def get_table_info(self, table_names: Optional[list[str]] = None) -> str:
+        """Get information about specified tables including schema and sample rows.
+
+        Args:
+            table_names: Optional list of table names. If None, uses all usable tables.
+
+        Returns:
+            Formatted string with table information
+        """
+        if table_names is None:
+            table_names = self.get_usable_table_names()
+
+        inspector = inspect(self._engine)
+        table_info = []
+
+        for table_name in table_names:
+            # Get columns
+            columns = inspector.get_columns(table_name, schema=self._schema)
+
+            # Build CREATE TABLE statement
+            create_table = f"CREATE TABLE {table_name} (\n"
+            column_defs = []
+            for col in columns:
+                col_type = str(col["type"])
+                nullable = "" if col.get("nullable", True) else " NOT NULL"
+                column_defs.append(f"  {col['name']} {col_type}{nullable}")
+            create_table += ",\n".join(column_defs)
+            create_table += "\n)"
+
+            table_info.append(create_table)
+
+            # Get sample rows
+            if self._sample_rows_in_table_info > 0:
+                try:
+                    query = text(
+                        f"SELECT * FROM {table_name} LIMIT {self._sample_rows_in_table_info}"
+                    )
+                    with self._engine.connect() as conn:
+                        result = conn.execute(query)
+                        rows = result.fetchall()
+                        if rows:
+                            table_info.append(
+                                f"\n{self._sample_rows_in_table_info} rows from {table_name} table:"
+                            )
+                            for row in rows:
+                                table_info.append(str(row))
+                except Exception as e:
+                    table_info.append(f"\nError fetching sample rows: {e}")
+
+            table_info.append("")  # Empty line between tables
+
+        return "\n".join(table_info)
+
+    def run(self, command: str, fetch: str = "all") -> str:
+        """Execute a SQL command and return results.
+
+        Args:
+            command: SQL command to execute
+            fetch: How to fetch results ('all', 'one', or 'cursor')
+
+        Returns:
+            Query results as a string
+        """
+        with self._engine.connect() as conn:
+            result = conn.execute(text(command))
+
+            if fetch == "all":
+                rows = result.fetchall()
+                return str(rows)
+            elif fetch == "one":
+                row = result.fetchone()
+                return str(row)
+            else:
+                return str(list(result))
+
+
+class SQLDatabaseToolkit:
+    """Toolkit for creating LangChain tools to interact with SQL databases."""
+
+    def __init__(self, db: SQLDatabase, llm: Any):
+        """Initialize SQL Database Toolkit.
+
+        Args:
+            db: SQLDatabase instance
+            llm: Language model (not used in tool execution, but kept for compatibility)
+        """
+        self._db = db
+        self._llm = llm
+
+    def get_tools(self) -> list:
+        """Get list of tools for SQL database interaction.
+
+        Returns:
+            List of LangChain Tool objects
+        """
+        from langchain_core.tools import StructuredTool
+
+        tools = [
+            StructuredTool.from_function(
+                name="sql_db_list_tables",
+                description="List all available tables in the database. "
+                "Use this to see what tables you can query. "
+                "Input should be an empty string.",
+                func=self._list_tables,
+            ),
+            StructuredTool.from_function(
+                name="sql_db_schema",
+                description="Get the schema and sample rows for specified tables. "
+                "Input should be a comma-separated list of table names. "
+                "Example input: 'table1, table2, table3'",
+                func=self._get_schema,
+            ),
+            StructuredTool.from_function(
+                name="sql_db_query",
+                description="Execute a SQL query against the database. "
+                "Input should be a valid SQL query. "
+                "Returns the query results. "
+                "If the query is not correct, an error message will be returned. "
+                "If an error is returned, rewrite the query and try again.",
+                func=self._query,
+            ),
+        ]
+
+        return tools
+
+    def _list_tables(self, _: str = "") -> str:
+        """List all tables in the database."""
+        tables = self._db.get_usable_table_names()
+        return ", ".join(tables)
+
+    def _get_schema(self, table_names: str) -> str:
+        """Get schema for specified tables.
+
+        Args:
+            table_names: Comma-separated list of table names
+
+        Returns:
+            Formatted schema information
+        """
+        # Parse table names
+        tables = [t.strip() for t in table_names.split(",")]
+        return self._db.get_table_info(tables)
+
+    def _query(self, query: str) -> str:
+        """Execute SQL query.
+
+        Args:
+            query: SQL query to execute
+
+        Returns:
+            Query results or error message
+        """
+        try:
+            result = self._db.run(query)
+            return result
+        except Exception as e:
+            return f"Error executing query: {str(e)}"

pixie_examples-0.1.1.dev3.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: pixie-examples
+Version: 0.1.1.dev3
+Summary: examples for using Pixie
+License: MIT
+License-File: LICENSE
+Author: Yiou Li
+Author-email: yol@gopixie.ai
+Requires-Python: >=3.11,<3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: beautifulsoup4 (>=4.14.3,<5.0.0)
+Requires-Dist: langchain (>=1.2.3,<2.0.0)
+Requires-Dist: langchain-openai (>=1.1.7,<2.0.0)
+Requires-Dist: langchain-text-splitters (>=1.1.0,<2.0.0)
+Requires-Dist: langgraph (>=1.0.5,<2.0.0)
+Requires-Dist: lxml (>=6.0.2,<7.0.0)
+Requires-Dist: numpy (>=2.4.1,<3.0.0)
+Requires-Dist: openai-agents (>=0.6.5,<0.7.0)
+Requires-Dist: openinference-instrumentation-crewai (>=0.1.17,<0.2.0)
+Requires-Dist: openinference-instrumentation-dspy (>=0.1.33,<0.2.0)
+Requires-Dist: openinference-instrumentation-google-adk (>=0.1.8,<0.2.0)
+Requires-Dist: openinference-instrumentation-openai-agents (>=1.4.0,<2.0.0)
+Requires-Dist: pixie-sdk (>=0.1.1.dev8,<0.2.0)
+Requires-Dist: pydantic (>=2.7.4,<3.0.0)
+Requires-Dist: pydantic-ai-slim (>=1.39.0,<2.0.0)
+Requires-Dist: pymarkdownlnt (>=0.9.34,<0.10.0)
+Requires-Dist: requests (>=2.32.5,<3.0.0)
+Requires-Dist: sqlalchemy (>=2.0.45,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Pixie Examples
+
+[![MIT License](https://img.shields.io/badge/License-MIT-red.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![Python Version](https://img.shields.io/badge/python-3.11%2B-blue?style=flat-square)](https://www.python.org/downloads/)
+[![Discord](https://img.shields.io/discord/1459772566528069715?style=flat-square&logo=Discord&logoColor=white&label=Discord&color=%23434EE4)](https://discord.gg/YMNYu6Z3)
+
+This repository contains a collection of example applications integrated with [**Pixie SDK**](https://github.com/yiouli/pixie-sdk-py) for interactive debugging.
+
+## Get Started
+
+> You can play with the demo site [here](https://gopixie.ai/?url=https://demo.yiouli.us/graphql) withou any setup.
+
+### 1. Setup
+
+Clone this repository:
+
+Install `pixie-examples` python package:
+
+```bash
+pip install pixie-examples
+```
+
+Create a `.env` file with your API keys:
+
+```ini
+# .env
+OPENAI_API_KEY=...
+# Add other API keys as needed for specific examples
+```
+
+Start the Pixie server:
+
+```bash
+pixie
+```
+
+### 2. Debug with Web UI
+
+Visit [gopixie.ai](https://gopixie.ai) to interact with and debug your applications through the web interface.
+
+## Important Links
+
+- [**Pixie SDK**](https://github.com/yiouli/pixie-sdk-py)
+- [**Documentation**](https://yiouli.github.io/pixie-sdk-py/)
+- [**Discord**](https://discord.gg/YMNYu6Z3)
+
+## Examples Catelog
+
+### Quickstart
+
+- **Basic Example**: Simple hello world application to get started with Pixie SDK
+
+### Pydantic AI Examples
+
+- **Bank Support**: Multi-turn chatbot for banking customer support
+- **Flight Booking**: Multi-agent system for flight booking
+- **Question Graph**: Graph-based question answering system
+- **SQL Generation**: Multi-step workflow for generating SQL queries
+- **Structured Output**: Examples of structured data handling
+
+### OpenAI Agents SDK Examples
+
+- **Customer Service**: Multi-agent customer service system
+- **Financial Research Agent**: Multi-step financial research workflow
+- **LLM-as-a-Judge**: Evaluation and judging patterns
+- **Routing**: Agent routing and handoffs
+
+### LangChain Examples
+
+- **Basic Agent**: Simple LangChain agent integration
+- **Customer Support**: Customer support chatbot
+- **Personal Assistant**: Multi-agent personal assistant
+- **SQL Agent**: SQL query generation with LangChain
+
+### LangGraph Examples
+
+- **RAG System**: Retrieval-augmented generation with LangGraph
+- **SQL Agent**: SQL agent built with LangGraph state machines
+

pixie_examples-0.1.1.dev3.dist-info/RECORD

@@ -0,0 +1,33 @@
+examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/langchain/README.md,sha256=xU8v1xtLYS9TtgLpJAdeu2zrRYK5w19hH_yvg_OsWxY,1179
+examples/langchain/__init__.py,sha256=mwSd_kA79bSHBMmBJL4NawrAow38QcOly4DUtieID3Q,35
+examples/langchain/basic_agent.py,sha256=TjsrMMoHJMQcV1WXvxVwWS0iiPhHglg_w510fgHdRwA,2771
+examples/langchain/customer_support.py,sha256=6r1lfUXVf1uiyle2FmnD3-FLh_KOwX4Xa1q3CJ3VXCA,7845
+examples/langchain/personal_assistant.py,sha256=5jIMzHFeGbo1H1RAagtd2b7gPfF_2dbq0oS9tt7m2Wk,5635
+examples/langchain/sql_agent.py,sha256=M5s9cQ0G3AbSm89s73WQ0Qy6CgC2TZyiAYlv2US6slY,5692
+examples/langgraph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/langgraph/langgraph_rag.py,sha256=H17pONi4MV_LX-4BxahrkGKDZwaWvL-1DhcTXf6DaDI,8296
+examples/langgraph/langgraph_sql_agent.py,sha256=XfsM_dZlqFzs5Qs4_Urc46srlxFrn1l9TtwsAKMt6Zc,8086
+examples/openai_agents_sdk/README.md,sha256=Q0iszfCK1lRzHoWCI9L5-f7LGLU-3OWSWXUsiBFBp4o,7088
+examples/openai_agents_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/openai_agents_sdk/customer_service.py,sha256=B4TOnUN7PbevQuLCpGKjct4nfqJmk13KiXN9COVf4wM,8420
+examples/openai_agents_sdk/financial_research_agent.py,sha256=crx5TTmCBpxqPJTOkb2ONtr0H4C154U1C3rdjGULLNQ,10585
+examples/openai_agents_sdk/llm_as_a_judge.py,sha256=vXO4ds79VIqNaITByGpBCeiOYR6jVowO8cHAKxMolWo,3440
+examples/openai_agents_sdk/routing.py,sha256=0SRLmT1Pywjbk4YgqT23n9AHSokbZHcIzdYe1V5IleQ,5268
+examples/pydantic_ai/.env.example,sha256=f-rbvXri1Rfy7Ya1tI4a4cPVWM1YvYHfR8CQEnnYdcg,944
+examples/pydantic_ai/README.md,sha256=Tz80pjaACzAP9WxYVwiWY7Gq03eJwLGsHMGtPj3OOWQ,6677
+examples/pydantic_ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/pydantic_ai/bank_support.py,sha256=z46pPLkpswljmRuI1rge5Y5NEpgMQY-yNcJU9HeZgiA,4199
+examples/pydantic_ai/flight_booking.py,sha256=cqZtuxME-Us0l9NFkd6Uz_gajeWtOTDkferEBBkNgMU,8133
+examples/pydantic_ai/question_graph.py,sha256=5BiiXDwnyUERmSK1LnXlpQNkItXDJEtXRQ2S0B3rmd0,4793
+examples/pydantic_ai/sql_gen.py,sha256=UK7Sm9Kpfex_OBwrQl9qH1VZUDjmXvzxqNn_EDPMIgA,4957
+examples/pydantic_ai/structured_output.py,sha256=505L_P_d3lU2GxB8yij7M3A-iMXMCxxrzl_B7Jq3ttE,1386
+examples/quickstart/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/quickstart/chatbot.py,sha256=UuN34P1QdgsF_InK2rNTuZ-yzIeJ9WWOskOjPHAWCr0,644
+examples/quickstart/sleepy_poet.py,sha256=XaP8FWW7rVsV16e3sTrY-9amkLUhL93AK9s5_lYIHSE,2914
+examples/quickstart/weather_agent.py,sha256=bRk7kcbPfJ18ywlqVqiwLbi9_z_LtESzaZr2bdLhN1M,3238
+examples/sql_utils.py,sha256=gIR_ViLzoIKTgY7RZnwCBftTscpFLSjRXewNx7TthoI,8125
+pixie_examples-0.1.1.dev3.dist-info/METADATA,sha256=gMYjUNMxLQLGSagE2VEEUPEJjruW3Y63Pwwcpb3kGc0,3884
+pixie_examples-0.1.1.dev3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+pixie_examples-0.1.1.dev3.dist-info/licenses/LICENSE,sha256=Qb3t92_AewWub67xNn9upFjh7PrOFF_45wqvHGklA1M,1074
+pixie_examples-0.1.1.dev3.dist-info/RECORD,,

pixie_examples-0.1.1.dev3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

pixie_examples-0.1.1.dev3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Finto Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.