langwatch 0.1.7 → 0.3.0-prerelease.1

package/examples/langgraph/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "langgraph-sdk-example",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "tsc && dotenv -- node dist/index.js",
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "LangWatch",
+  "type": "module",
+  "license": "MIT",
+  "dependencies": {
+    "@langchain/openai": "^0.6.3",
+    "@langchain/core": "^0.3.66",
+    "langchain": "^0.3.30",
+    "@langchain/langgraph": "^0.4.2",
+    "@opentelemetry/context-async-hooks": "^2.0.1",
+    "@opentelemetry/sdk-node": "^0.203.0",
+    "cli-markdown": "^3.5.1",
+    "langwatch": "file:../../"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2",
+    "dotenv-cli": "^10.0.0"
+  }
+}

package/examples/langgraph/src/cli-markdown.d.ts

@@ -0,0 +1,137 @@
+declare module 'cli-markdown' {
+  export interface CliMarkdownOptions {
+    /**
+     * Custom styles for different markdown elements
+     */
+    styles?: {
+      /**
+       * Style for headings (h1, h2, h3, etc.)
+       */
+      heading?: string;
+      /**
+       * Style for bold text
+       */
+      bold?: string;
+      /**
+       * Style for italic text
+       */
+      italic?: string;
+      /**
+       * Style for code blocks
+       */
+      code?: string;
+      /**
+       * Style for inline code
+       */
+      inlineCode?: string;
+      /**
+       * Style for links
+       */
+      link?: string;
+      /**
+       * Style for lists
+       */
+      list?: string;
+      /**
+       * Style for blockquotes
+       */
+      blockquote?: string;
+      /**
+       * Style for horizontal rules
+       */
+      hr?: string;
+    };
+    /**
+     * Whether to preserve line breaks
+     */
+    preserveLineBreaks?: boolean;
+    /**
+     * Custom renderer functions for different markdown elements
+     */
+    renderers?: {
+      /**
+       * Custom renderer for headings
+       */
+      heading?: (text: string, level: number) => string;
+      /**
+       * Custom renderer for paragraphs
+       */
+      paragraph?: (text: string) => string;
+      /**
+       * Custom renderer for lists
+       */
+      list?: (items: string[], ordered: boolean) => string;
+      /**
+       * Custom renderer for list items
+       */
+      listItem?: (text: string, index: number) => string;
+      /**
+       * Custom renderer for code blocks
+       */
+      code?: (code: string, language?: string) => string;
+      /**
+       * Custom renderer for inline code
+       */
+      inlineCode?: (code: string) => string;
+      /**
+       * Custom renderer for links
+       */
+      link?: (text: string, url: string) => string;
+      /**
+       * Custom renderer for images
+       */
+      image?: (alt: string, url: string) => string;
+      /**
+       * Custom renderer for blockquotes
+       */
+      blockquote?: (text: string) => string;
+      /**
+       * Custom renderer for horizontal rules
+       */
+      hr?: () => string;
+      /**
+       * Custom renderer for emphasis (bold/italic)
+       */
+      emphasis?: (text: string, type: 'bold' | 'italic') => string;
+    };
+    /**
+     * Maximum width for text wrapping
+     */
+    maxWidth?: number;
+    /**
+     * Whether to enable ANSI color codes
+     */
+    colors?: boolean;
+    /**
+     * Custom color theme
+     */
+    theme?: {
+      /**
+       * Color for headings
+       */
+      heading?: string;
+      /**
+       * Color for links
+       */
+      link?: string;
+      /**
+       * Color for code
+       */
+      code?: string;
+      /**
+       * Color for blockquotes
+       */
+      blockquote?: string;
+    };
+  }
+
+  /**
+   * Converts markdown text to formatted CLI output
+   * @param markdown - The markdown text to convert
+   * @param options - Configuration options for the conversion
+   * @returns Formatted CLI text
+   */
+  function cliMarkdown(markdown: string, options?: CliMarkdownOptions): string;
+
+  export = cliMarkdown;
+}

package/examples/langgraph/src/index.ts

@@ -0,0 +1,196 @@
+import { setupLangWatch } from "langwatch/node";
+import { LangWatchCallbackHandler } from "langwatch/observability/instrumentation/langchain";
+import { getLangWatchTracer } from "langwatch";
+import { semconv } from "langwatch/observability";
+import { ChatOpenAI } from "@langchain/openai";
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import * as readline from "readline";
+import cliMarkdown from "cli-markdown";
+
+await setupLangWatch();
+
+const tracer = getLangWatchTracer("langgraph-sdk-example");
+
+// Define the state interface for our multi-agent workflow
+interface WorkflowState {
+  userQuery: string;
+  analysis: string;
+  recommendation: string;
+  finalResponse: string;
+}
+
+async function main() {
+  const threadId = crypto.randomUUID();
+  const langWatchCallback = new LangWatchCallbackHandler();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log('🤖 Multi-Agent Workflow started! Type "quit" to exit.');
+  console.log("This example demonstrates a workflow with:");
+  console.log("1. Query Analysis Agent");
+  console.log("2. Recommendation Agent");
+  console.log("3. Response Synthesis Agent");
+  console.log("---");
+
+  // Initialize LangChain chat model
+  const chatModel = new ChatOpenAI({
+    modelName: "gpt-4o-mini",
+    temperature: 0.7,
+    callbacks: [langWatchCallback],
+  });
+
+  // Agent 1: Query Analysis Agent
+  const analyzeQuery = async (userQuery: string): Promise<string> => {
+    const analysisPrompt = new SystemMessage(
+      "You are an expert at analyzing user queries. Analyze the user's query and provide insights about what they're asking for, their intent, and any specific requirements."
+    );
+
+    const result = await chatModel.invoke([
+      analysisPrompt,
+      new HumanMessage(`Analyze this query: ${userQuery}`)
+    ]);
+
+    return result.content as string;
+  };
+
+  // Agent 2: Recommendation Agent
+  const generateRecommendation = async (userQuery: string, analysis: string): Promise<string> => {
+    const recommendationPrompt = new SystemMessage(
+      "You are an expert at providing helpful recommendations. Based on the analysis, provide specific, actionable recommendations."
+    );
+
+    const result = await chatModel.invoke([
+      recommendationPrompt,
+      new HumanMessage(`Based on this analysis: ${analysis}\n\nProvide recommendations for: ${userQuery}`)
+    ]);
+
+    return result.content as string;
+  };
+
+  // Agent 3: Response Synthesis Agent
+  const synthesizeResponse = async (userQuery: string, analysis: string, recommendation: string): Promise<string> => {
+    const synthesisPrompt = new SystemMessage(
+      "You are an expert at synthesizing information into clear, helpful responses. Combine the analysis and recommendations into a comprehensive, well-structured response."
+    );
+
+    const result = await chatModel.invoke([
+      synthesisPrompt,
+      new HumanMessage(`Original Query: ${userQuery}\n\nAnalysis: ${analysis}\n\nRecommendations: ${recommendation}\n\nSynthesize this into a comprehensive response.`)
+    ]);
+
+    return result.content as string;
+  };
+
+  // Main workflow function
+  const runWorkflow = async (userQuery: string): Promise<WorkflowState> => {
+    console.log("🔍 Step 1: Analyzing query...");
+    const analysis = await analyzeQuery(userQuery);
+
+    console.log("💡 Step 2: Generating recommendations...");
+    const recommendation = await generateRecommendation(userQuery, analysis);
+
+    console.log("🎯 Step 3: Synthesizing final response...");
+    const finalResponse = await synthesizeResponse(userQuery, analysis, recommendation);
+
+    return {
+      userQuery,
+      analysis,
+      recommendation,
+      finalResponse,
+    };
+  };
+
+  while (true) {
+    let finish = false;
+
+    await tracer.withActiveSpan("workflow_iteration", {
+      attributes: {
+        [semconv.ATTR_LANGWATCH_THREAD_ID]: threadId,
+      },
+    }, async (span) => {
+      try {
+        // Get user input
+        const userInput = await new Promise<string>((resolve) => {
+          rl.question("You: ", resolve);
+        });
+
+        // Check for exit command
+        if (
+          userInput.toLowerCase() === "quit" ||
+          userInput.toLowerCase() === "exit"
+        ) {
+          console.log("👋 Goodbye!");
+          finish = true;
+          return;
+        }
+
+        // Skip empty input
+        if (!userInput.trim()) {
+          return;
+        }
+
+        console.log("🤖 Processing through multi-agent workflow...");
+
+        // Execute the workflow
+        const result = await runWorkflow(userInput);
+
+        // Display the workflow results
+        console.log("\n📊 Workflow Results:");
+        console.log("---");
+
+        console.log("🔍 Analysis:");
+        console.log(cliMarkdown(result.analysis, {
+          colors: true,
+          maxWidth: 80,
+          theme: {
+            heading: "cyan",
+            link: "blue",
+            code: "green",
+            blockquote: "yellow",
+          },
+        }));
+
+        console.log("\n💡 Recommendations:");
+        console.log(cliMarkdown(result.recommendation, {
+          colors: true,
+          maxWidth: 80,
+          theme: {
+            heading: "cyan",
+            link: "blue",
+            code: "green",
+            blockquote: "yellow",
+          },
+        }));
+
+        console.log("\n🎯 Final Response:");
+        console.log(cliMarkdown(result.finalResponse, {
+          colors: true,
+          maxWidth: 80,
+          theme: {
+            heading: "cyan",
+            link: "blue",
+            code: "green",
+            blockquote: "yellow",
+          },
+        }));
+
+        console.log("---");
+      } catch (error) {
+        console.error("❌ Error:", error);
+        console.log("Please try again.");
+      }
+    });
+
+    if (finish) {
+      break;
+    }
+  }
+
+  rl.close();
+}
+
+// Run the multi-agent workflow
+main().catch(console.error);

package/examples/langgraph/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "node16",
+    "moduleResolution": "node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/examples/mastra/.env.example

@@ -0,0 +1,2 @@
+LANGWATCH_API_KEY=""
+OPENAI_API_KEY=""

package/examples/mastra/README.md

@@ -0,0 +1,57 @@
+# Mastra Weather Agent Example
+
+This example demonstrates how to use LangWatch with Mastra to create a weather agent that can provide weather information and suggest activities based on weather conditions.
+
+## Features
+
+- **Weather Agent**: An AI agent that can fetch weather data and suggest activities
+- **Weather Tool**: A tool that fetches real-time weather data from Open-Meteo API
+- **CLI Chatbox Interface**: Interactive command-line interface for chatting with the weather agent
+- **LangWatch Integration**: Full observability and tracing with LangWatch
+
+## Getting Started
+
+1. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+2. Set up your environment variables:
+   ```bash
+   cp .env.example .env
+   # Add your OpenAI API key to .env
+   ```
+
+3. Run the CLI chatbox interface:
+   ```bash
+   npm run cli
+   ```
+
+4. Or run the workflow example:
+   ```bash
+   npm start
+   ```
+
+## Usage
+
+### CLI Chatbox Interface
+
+The CLI interface allows you to interact with the weather agent in a conversational manner:
+
+```bash
+npm run cli
+```
+
+Example conversation:
+```
+🌤️  Weather Agent Chatbot started! Type "quit" to exit.
+Ask me about weather for any location and I'll help you plan activities!
+---
+You: What's the weather like in Paris?
+🌤️  Checking weather and planning activities...
+[Agent responds with weather information and activity suggestions]
+```
+
+### Workflow Example
+
+The workflow example demonstrates how to use Mastra workflows to fetch weather data and plan activities programmatically.