euriai 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

euriai/crewai.py

@@ -17,7 +17,8 @@ except ImportError:
     class Task:
         pass
     class Process:
-        pass
+        sequential = "sequential"
+        parallel = "parallel"
     class LLM:
         pass
 

euriai/euri_embed.py

@@ -34,13 +34,29 @@ class EuriaiLlamaIndexEmbedding(BaseEmbedding):
         response.raise_for_status()
         return [np.array(obj["embedding"]).tolist() for obj in response.json()["data"]]
 
+    # Abstract methods required by BaseEmbedding (with underscore prefixes)
+    def _get_text_embedding(self, text: str) -> List[float]:
+        """Get embedding for a single text. Required abstract method."""
+        return self._post_embedding([text])[0]
+
+    def _get_query_embedding(self, query: str) -> List[float]:
+        """Get embedding for a query string. Required abstract method."""
+        return self._get_text_embedding(query)
+        
+    async def _aget_query_embedding(self, query: str) -> List[float]:
+        """Async version of get_query_embedding. Required abstract method."""
+        # For now, we don't support async, so we'll use the sync version
+        # In a real implementation, you'd want to use aiohttp or similar
+        return self._get_query_embedding(query)
+
+    # Public methods for backward compatibility
     def get_text_embedding(self, text: str) -> List[float]:
         """Get embedding for a single text."""
-        return self._post_embedding([text])[0]
+        return self._get_text_embedding(text)
 
     def get_query_embedding(self, query: str) -> List[float]:
         """Get embedding for a query string."""
-        return self.get_text_embedding(query)
+        return self._get_query_embedding(query)
         
     def get_text_embeddings(self, texts: List[str]) -> List[List[float]]:
         """Get embeddings for multiple texts."""
@@ -48,5 +64,4 @@ class EuriaiLlamaIndexEmbedding(BaseEmbedding):
         
     async def aget_query_embedding(self, query: str) -> List[float]:
         """Async version of get_query_embedding."""
-        # We don't support async, so raise NotImplementedError
-        raise NotImplementedError("Async embeddings not supported")
+        return await self._aget_query_embedding(query)

euriai/langchain.py

@@ -482,11 +482,9 @@ class EuriaiChatModel(BaseChatModel):
         self, 
         schema: Union[Dict, Type[BaseModel]], 
         **kwargs: Any
-    ) -> "EuriaiChatModel":
+    ) -> "EuriaiStructuredChatModel":
         """Create a version that returns structured output."""
-        # This would need to be implemented with proper schema validation
-        # For now, return self with structured output enabled
-        return self.__class__(
+        return EuriaiStructuredChatModel(
             api_key=self.api_key,
             model=self.model,
             temperature=self.temperature,
@@ -497,11 +495,136 @@ class EuriaiChatModel(BaseChatModel):
             streaming=self.streaming,
             supports_function_calling=self.supports_function_calling,
             supports_structured_output=True,
-            _structured_output_schema=schema,
+            schema=schema,
             **kwargs
         )
 
 
+class EuriaiStructuredChatModel(EuriaiChatModel):
+    """
+    EuriaiChatModel with structured output support.
+    
+    This class extends EuriaiChatModel to parse responses into structured Pydantic models.
+    """
+    
+    def __init__(self, schema: Union[Dict, Type[BaseModel]], **kwargs):
+        # Initialize the parent class first
+        super().__init__(**kwargs)
+        
+        # Store schema in private attributes to avoid Pydantic conflicts
+        self._output_schema = schema
+        self._schema_name = getattr(schema, '__name__', 'OutputSchema')
+        
+    @property
+    def schema(self):
+        """Get the output schema."""
+        return self._output_schema
+    
+    @property
+    def schema_name(self):
+        """Get the schema name."""
+        return self._schema_name
+        
+    def _get_json_schema(self) -> Dict[str, Any]:
+        """Generate JSON schema from the Pydantic model."""
+        if hasattr(self.schema, 'model_json_schema'):
+            # Pydantic v2
+            return self.schema.model_json_schema()
+        elif hasattr(self.schema, 'schema'):
+            # Pydantic v1
+            return self.schema.schema()
+        else:
+            # Dictionary schema
+            return self.schema
+    
+    def _create_structured_prompt(self, original_prompt: str) -> str:
+        """Create a prompt that requests structured JSON output."""
+        json_schema = self._get_json_schema()
+        
+        structured_prompt = f"""{original_prompt}
+
+Please respond with a valid JSON object that matches this exact schema:
+```json
+{json.dumps(json_schema, indent=2)}
+```
+
+Your response must be valid JSON that can be parsed. Do not include any other text outside the JSON object."""
+        
+        return structured_prompt
+    
+    def _parse_structured_response(self, response_content: str) -> Any:
+        """Parse the response content into the structured format."""
+        try:
+            # Try to find JSON in the response
+            response_content = response_content.strip()
+            
+            # Handle cases where the response might have extra text
+            if '```json' in response_content:
+                # Extract JSON from code block
+                start = response_content.find('```json') + 7
+                end = response_content.find('```', start)
+                if end == -1:
+                    end = len(response_content)
+                json_str = response_content[start:end].strip()
+            elif response_content.startswith('{') and response_content.endswith('}'):
+                # Response is already JSON
+                json_str = response_content
+            else:
+                # Try to find JSON object in the response
+                import re
+                json_match = re.search(r'\{.*\}', response_content, re.DOTALL)
+                if json_match:
+                    json_str = json_match.group(0)
+                else:
+                    raise ValueError("No JSON object found in response")
+            
+            # Parse JSON
+            parsed_data = json.loads(json_str)
+            
+            # Convert to Pydantic model if schema is a BaseModel
+            if hasattr(self.schema, 'model_validate'):
+                # Pydantic v2
+                return self.schema.model_validate(parsed_data)
+            elif hasattr(self.schema, 'parse_obj'):
+                # Pydantic v1
+                return self.schema.parse_obj(parsed_data)
+            else:
+                # Dictionary schema - return parsed data
+                return parsed_data
+                
+        except Exception as e:
+            # Fallback: return raw response if parsing fails
+            raise ValueError(f"Failed to parse structured output: {e}\nResponse: {response_content}")
+    
+    def _messages_to_prompt(self, messages: List[BaseMessage]) -> str:
+        """Convert LangChain messages to a single prompt string with structured output instructions."""
+        # Get the original prompt
+        original_prompt = super()._messages_to_prompt(messages)
+        
+        # Add structured output instructions
+        return self._create_structured_prompt(original_prompt)
+    
+    def invoke(self, input, config=None, **kwargs):
+        """Invoke the model and return structured output."""
+        # Get the regular AI message response
+        response = super().invoke(input, config, **kwargs)
+        
+        # Parse the response content into structured format
+        structured_result = self._parse_structured_response(response.content)
+        
+        return structured_result
+    
+    async def ainvoke(self, input, config=None, **kwargs):
+        """Async invoke the model and return structured output."""
+        # Get the regular AI message response
+        response = await super().ainvoke(input, config, **kwargs)
+        
+        # Parse the response content into structured format
+        structured_result = self._parse_structured_response(response.content)
+        
+        return structured_result
+
+
 class EuriaiEmbeddings(Embeddings):
     """
     Enhanced LangChain Embeddings implementation using Euri API.

{euriai-1.0.2.dist-info → euriai-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euriai
-Version: 1.0.2
+Version: 1.0.4
 Summary: Python client for Euri API (euron.one) with CLI, LangChain, and LlamaIndex integration
 Author: Euri
 Author-email: tech@euron.one
@@ -52,10 +52,44 @@ Dynamic: summary
 
 ## 🔧 Installation 
 
+### Basic Installation
 ```bash
 pip install euriai
 ```
 
+### Framework-Specific Installation
+For framework integrations, install the specific extras you need:
+
+```bash
+# For LangChain integration
+pip install euriai[langchain]
+
+# For LlamaIndex integration  
+pip install euriai[llama-index]
+
+# For LangGraph integration
+pip install euriai[langgraph]
+
+# For CrewAI integration
+pip install euriai[crewai]
+
+# For AutoGen integration
+pip install euriai[autogen]
+
+# For SmolAgents integration
+pip install euriai[smolagents]
+
+# Install multiple frameworks
+pip install euriai[langchain,llama-index,langgraph]
+
+# Install all frameworks
+pip install euriai[langchain,llama-index,langgraph,crewai,autogen,smolagents]
+```
+
+> **Note**: The n8n integration only requires the base installation as it uses standard HTTP requests.
+
+---
+
 ## 🚀 Python Usage
 
 ### Text Generation
@@ -107,16 +141,20 @@ List all supported model IDs with recommended use-cases and temperature/token ad
 euriai --models
 ```
 
-## 🤖 LangChain Integration
+## 🤖 Framework Integrations
 
-### Text Generation
+### LangChain Integration
+
+**Installation**: `pip install euriai[langchain]`
+
+#### Text Generation
 
 Use Euriai with LangChain directly:
 
 ```python
-from euriai import EuriaiLangChainLLM
+from euriai import EuriaiChatModel
 
-llm = EuriaiLangChainLLM(
+llm = EuriaiChatModel(
     api_key="your_api_key",
     model="gpt-4.1-nano", 
     temperature=0.7,
@@ -126,66 +164,25 @@ llm = EuriaiLangChainLLM(
 print(llm.invoke("Write a poem about time travel."))
 ```
 
-### Embeddings
+#### Embeddings
 
 Use Euriai embeddings with LangChain:
 
 ```python
-from euriai.langchain_embed import EuriaiEmbeddings
+from euriai import EuriaiEmbeddings
 
 embedding_model = EuriaiEmbeddings(api_key="your_key")
 print(embedding_model.embed_query("What's AI?")[:5])  # Print first 5 dimensions
 ```
 
-## Usage Examples
-
-### CrewAI Integration
-```python
-from euriai import EuriaiCrewAI
-
-# Example: Create a crew from YAML config files
-crew = EuriaiCrewAI.from_yaml('agents.yaml', 'tasks.yaml')
-result = crew.run(inputs={"topic": "AI in Healthcare"})
-print(result)
-
-# Or programmatically
-crew = EuriaiCrewAI()
-crew.add_agent("researcher", {
-    "role": "Researcher",
-    "goal": "Find information about {topic}",
-    "llm": "openai/gpt-4o"
-})
-crew.add_task("research_task", {
-    "description": "Research the topic {topic}",
-    "agent": "researcher"
-})
-crew.build_crew()
-result = crew.run(inputs={"topic": "AI in Healthcare"})
-print(result)
-```
-
-### AutoGen Integration
-```python
-from euriai import EuriaiAutoGen
+### LlamaIndex Integration
 
-autogen = EuriaiAutoGen()
-# Add an agent (see AutoGen docs for agent config details)
-agent = autogen.add_agent({
-    "name": "assistant",
-    "llm_config": {"api_key": "YOUR_OPENAI_KEY", "model": "gpt-4o"}
-})
-# Run a chat
-response = autogen.run_chat("Hello, what is the weather today?")
-print(response)
-# Access chat history
-print(autogen.get_history())
-```
+**Installation**: `pip install euriai[llama-index]`
 
-### LlamaIndex Integration
 ```python
 from euriai import EuriaiLlamaIndex
 
-llama = EuriaiLlamaIndex()
+llama = EuriaiLlamaIndex(api_key="your_api_key")
 llama.add_documents([
     "Abraham Lincoln was the 16th President of the United States.",
     "He led the country during the American Civil War."
@@ -196,6 +193,9 @@ print(response)
 ```
 
 ### LangGraph Integration
+
+**Installation**: `pip install euriai[langgraph]`
+
 ```python
 from euriai import EuriaiLangGraph
 
@@ -210,27 +210,67 @@ def farewell_node(state):
     return state
 
 # Create the graph
-graph = EuriaiLangGraph()
+graph = EuriaiLangGraph(api_key="your_api_key")
 graph.add_node("greet", greet_node)
 graph.add_node("farewell", farewell_node)
 graph.add_edge("greet", "farewell")
-graph.set_state({"name": "Alice"})
-result = graph.run()
+graph.set_entry_point("greet")
+graph.set_finish_point("farewell")
+result = graph.run({"name": "Alice"})
 print(result)
 ```
 
----
+### CrewAI Integration
 
-## 2. **SmolAgents Integration**
+**Installation**: `pip install euriai[crewai]`
+
+```python
+from euriai import EuriaiCrewAI
+
+# Example: Create a crew from YAML config files
+crew = EuriaiCrewAI(api_key="your_api_key")
+crew.add_agent("researcher", {
+    "role": "Researcher",
+    "goal": "Find information about {topic}",
+    "backstory": "You are an expert researcher"
+})
+crew.add_task("research_task", {
+    "description": "Research the topic {topic}",
+    "agent": "researcher"
+})
+crew.build_crew()
+result = crew.run(inputs={"topic": "AI in Healthcare"})
+print(result)
+```
+
+### AutoGen Integration
+
+**Installation**: `pip install euriai[autogen]`
+
+```python
+from euriai import EuriaiAutoGen
+
+autogen = EuriaiAutoGen(api_key="your_api_key")
+# Add an agent (see AutoGen docs for agent config details)
+agent = autogen.create_assistant_agent(
+    name="assistant",
+    system_message="You are a helpful assistant",
+    model="gpt-4.1-nano"
+)
+# Run a chat
+response = autogen.initiate_chat(agent, message="Hello, what is the weather today?")
+print(response)
+```
+
+### SmolAgents Integration
+
+**Installation**: `pip install euriai[smolagents]`
 
 ```python
 from euriai import EuriaiSmolAgent
 
 # Define a tool using the @tool decorator
-try:
-    from smolagents import tool
-except ImportError:
-    raise ImportError("Please install smolagents: pip install smolagents")
+from smolagents import tool
 
 @tool
 def add(a: int, b: int) -> int:
@@ -238,14 +278,14 @@ def add(a: int, b: int) -> int:
     return a + b
 
 # Create the agent with the tool
-agent = EuriaiSmolAgent(tools=[add])
+agent = EuriaiSmolAgent(api_key="your_api_key", tools=[add])
 response = agent.run("What is 2 + 3?")
 print(response)
 ```
 
----
+### n8n Integration
 
-## 3. **n8n Integration**
+**Installation**: Basic installation only (`pip install euriai`)
 
 ```python
 from euriai import EuriaiN8N
@@ -262,8 +302,17 @@ print(result)
 
 ---
 
-**You can copy-paste these code blocks into your client documentation or UI for user reference.**  
-If you want advanced examples (e.g., multi-tool SmolAgents, LangGraph with more nodes, or n8n with authentication), just let me know!
+## 🔍 Framework Status
+
+| Framework | Status | Installation Command | Notes |
+|-----------|--------|---------------------|-------|
+| LangChain | ✅ Working | `pip install euriai[langchain]` | Full compatibility |
+| LlamaIndex | ✅ Working | `pip install euriai[llama-index]` | Full compatibility |
+| n8n | ✅ Working | `pip install euriai` | No extra dependencies |
+| LangGraph | ⚠️ Requires Install | `pip install euriai[langgraph]` | Install required |
+| CrewAI | ⚠️ Requires Install | `pip install euriai[crewai]` | Install required |
+| AutoGen | ⚠️ Requires Install | `pip install euriai[autogen]` | Install required |
+| SmolAgents | ⚠️ Requires Install | `pip install euriai[smolagents]` | Install required |
 
 ## 📘 Documentation
 

{euriai-1.0.2.dist-info → euriai-1.0.4.dist-info}/RECORD

@@ -2,17 +2,17 @@ euriai/__init__.py,sha256=WE4zl0HNxDm4zwR3d0uRyjl3fjcD_pccKvPsbtuDysw,916
 euriai/autogen.py,sha256=4YAHrY65YYOKVsBjQa9G8pr-_Xxss1uR08qLAFzo7Rk,16023
 euriai/cli.py,sha256=hF1wiiL2QQSfWf8WlLQyNVDBd4YkbiwmMSoPxVbyPTM,3290
 euriai/client.py,sha256=L-o6hv9N3md-l-hz-kz5nYVaaZqnrREZlo_0jguhF7E,4066
-euriai/crewai.py,sha256=eeDfZQC9LtEePSnaj94DA0Kcb8Ayq0Gn_eDSQwbcMBU,7543
+euriai/crewai.py,sha256=nfMMOOhKiCIc2v42nj2Zf9rP0U5m4GrfK_6zkXL77gw,7594
 euriai/embedding.py,sha256=uP66Ph1k9Ou6J5RAkztJxlfyj0S0MESOvZ4ulhnVo-o,1270
 euriai/euri_chat.py,sha256=DEAiet1ReRwB4ljkPYaTl1Nb5uc20-JF-3PQjGQZXk4,3567
-euriai/euri_embed.py,sha256=VE-RLUb5bYnEFA_dxFkj2c3Jr_SYyJKPmFOzsDOR0Ys,2137
-euriai/langchain.py,sha256=K8yJdkB9sUiLQj1kt_IJ_cNBWLEimo7xNgGedmdkdsc,30109
+euriai/euri_embed.py,sha256=g7zs1G-ZBDJjOGJtkkfIcV4LPtRcm9wpVWmrfMGn5EM,2919
+euriai/langchain.py,sha256=gVF9eh21RC1WtDn7SQoEREUDqOObm5IRx6BFZtB5xcc,34968
 euriai/langgraph.py,sha256=sw9e-PnfwAwmp_tUCnAGIUB78GyJsMkAzxOGvFUafiM,34128
 euriai/llamaindex.py,sha256=c-ujod2bjL6QIvfAyuIxm1SvSCS00URFElYybKQ5Ew0,26551
 euriai/n8n.py,sha256=hjkckqyW_hZNL78UkBCof1WvKCKCIjwdvZdAgx6NrB8,3764
 euriai/smolagents.py,sha256=xlixGx2IWzAPTpSJGsYIK2L-SHGY9Mw1-8GbwVsEYtU,28507
-euriai-1.0.2.dist-info/METADATA,sha256=S9UtbT2UjLIHakIbQlJDfR3EZv2p-PFsjq_mzvSlJ-U,6881
-euriai-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-euriai-1.0.2.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
-euriai-1.0.2.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
-euriai-1.0.2.dist-info/RECORD,,
+euriai-1.0.4.dist-info/METADATA,sha256=W-vrzgWEy1eDQLuzM31kI278KnEl6rVP81LBwPN1Db8,8417
+euriai-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+euriai-1.0.4.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
+euriai-1.0.4.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
+euriai-1.0.4.dist-info/RECORD,,