In this tutorial, we provide a practical guide for implementing LangGraph, a streamlined, graph-based AI orchestration framework, integrated seamlessly with Anthropic’s Claude API. Through detailed, executable code optimized for Google Colab, developers learn how to build and visualize AI workflows as interconnected nodes performing distinct tasks, such as generating concise answers, critically analyzing responses, and automatically composing technical blog content. The compact implementation highlights LangGraph’s intuitive node-graph architecture. It can manage complex sequences of Claude-powered natural language tasks, from basic question-answering scenarios to advanced content generation pipelines. from getpass import getpass import os anthropic_key = getpass("Enter your Anthropic API key: ") os.environ["ANTHROPIC_API_KEY"] = anthropic_key print("Key set:", "ANTHROPIC_API_KEY" in os.environ) We securely prompt users to input their Anthropic API key using Python’s getpass module, ensuring sensitive data isn’t displayed. It then sets this key as an environment variable (ANTHROPIC_API_KEY) and confirms successful storage. import os import json import requests from typing import Dict, List, Any, Callable, Optional, Union from dataclasses import dataclass, field import networkx as nx import matplotlib.pyplot as plt from IPython.display import display, HTML, clear_output We import essential libraries for building and visualizing structured AI workflows. It includes modules for handling data (json, requests, dataclasses), graph creation and visualization (networkx, matplotlib), interactive notebook display (IPython.display), and type annotations (typing) for clarity and maintainability. try: import anthropic except ImportError: print("Installing anthropic package...") !pip install -q anthropic import anthropic from anthropic import Anthropic We ensure the anthropic Python package is available for use. It attempts to import the module and, if not found, automatically installs it using pip in a Google Colab environment. After installation, it imports the Anthropic client, essential for interacting with Claude models via the Anthropic API. 4o @dataclass class NodeConfig: name: str function: Callable inputs: List[str] = field(default_factory=list) outputs: List[str] = field(default_factory=list) config: Dict[str, Any] = field(default_factory=dict) This NodeConfig data class defines the structure of each node in the LangGraph workflow. Each node has a name, an executable function, optional inputs and outputs, and an optional config dictionary to store additional parameters. This setup allows for modular, reusable node definitions for graph-based AI tasks. class LangGraph: def __init__(self, api_key: Optional[str] = None): self.api_key = api_key or os.environ.get("ANTHROPIC_API_KEY") if not self.api_key: from google.colab import userdata try: self.api_key = userdata.get('ANTHROPIC_API_KEY') if not self.api_key: raise ValueError("No API key found") except: print("No Anthropic API key found in environment variables or Colab secrets.") self.api_key = input("Please enter your Anthropic API key: ") if not self.api_key: raise ValueError("Please provide an Anthropic API key") self.client = Anthropic(api_key=self.api_key) self.graph = nx.DiGraph() self.nodes = {} self.state = {} def add_node(self, node_config: NodeConfig): self.nodes[node_config.name] = node_config self.graph.add_node(node_config.name) for input_node in node_config.inputs: if input_node in self.nodes: self.graph.add_edge(input_node, node_config.name) return self def claude_node(self, name: str, prompt_template: str, model: str = "claude-3-7-sonnet-20250219", inputs: List[str] = None, outputs: List[str] = None, system_prompt: str = None): """Convenience method to create a Claude API node""" inputs = inputs or [] outputs = outputs or [name + "_response"] def claude_fn(state, **kwargs): prompt = prompt_template for k, v in state.items(): if isinstance(v, str): prompt = prompt.replace(f"{{{k}}}", v) message_params = { "model": model, "max_tokens": 1000, "messages": [{"role": "user", "content": prompt}] } if system_prompt: message_params["system"] = system_prompt response = self.client.messages.create(**message_params) return response.content[0].text node_config = NodeConfig( name=name, function=claude_fn, inputs=inputs, outputs=outputs, config={"model": model, "prompt_template": prompt_template} ) return self.add_node(node_config) def transform_node(self, name: str, transform_fn: Callable, inputs: List[str] = None, outputs: List[str] = None): """Add a data transformation node""" inputs = inputs or [] outputs = outputs or [name + "_output"] node_config = NodeConfig( name=name, function=transform_fn, inputs=inputs, outputs=outputs ) return self.add_node(node_config) def visualize(self): """Visualize the graph""" plt.figure(figsize=(10, 6)) pos = nx.spring_layout(self.graph) nx.draw(self.graph, pos, with_labels=True, node_color="lightblue", node_size=1500, arrowsize=20, font_size=10) plt.title("LangGraph Flow") plt.tight_layout() plt.show() print("\nGraph Structure:") for node in self.graph.nodes(): successors = list(self.graph.successors(node)) if successors: print(f" {node} → {', '.join(successors)}") else: print(f" {node} (endpoint)") print() def _get_execution_order(self): """Determine execution order based on dependencies""" try: return list(nx.topological_sort(self.graph)) except nx.NetworkXUnfeasible: raise ValueError("Graph contains a cycle") def execute(self, initial_state: Dict[str, Any] = None): """Execute the graph in topological order""" self.state = initial_state or {} execution_order = self._get_execution_order() print("Executing LangGraph flow:") for node_name in execution_order: print(f"- Running node: {node_name}") node = self.nodes[node_name] inputs = {k: self.state.get(k) for k in node.inputs if k in self.state} result = node.function(self.state, **inputs) if len(node.outputs) == 1: self.state[node.outputs[0]] = result elif isinstance(result, (list, tuple)) and len(result) == len(node.outputs): for i, output_name in enumerate(node.outputs): self.state[output_name] = result[i] print("Execution completed!") return self.state def run_example(question="What are the key benefits of using a graph-based architecture for AI workflows?"): """Run an example LangGraph flow with a predefined question""" print(f"Running example with question: '{question}'") graph = LangGraph() def question_provider(state, **kwargs): return question graph.transform_node( name="question_provider", transform_fn=question_provider, outputs=["user_question"] ) graph.claude_node( name="question_answerer", prompt_template="Answer this question clearly and concisely: {user_question}", inputs=["user_question"], outputs=["answer"], system_prompt="You are a helpful AI assistant." ) graph.claude_node( name="answer_analyzer", prompt_template="Analyze if this answer addresses the question well: Question: {user_question}\nAnswer: {answer}", inputs=["user_question", "answer"], outputs=["analysis"], system_prompt="You are a critical evaluator. Be brief but thorough." ) graph.visualize() result = graph.execute() print("\n" + "="*50) print("EXECUTION RESULTS:") print("="*50) print(f"\n🔍 QUESTION:\n{result.get('user_question')}\n") print(f"📝 ANSWER:\n{result.get('answer')}\n") print(f"✅ ANALYSIS:\n{result.get('analysis')}") print("="*50 + "\n") return graph The LangGraph class implements a lightweight framework for constructing and executing graph-based AI workflows using Claude from Anthropic. It allows users to define modular nodes, either Claude-powered prompts or custom transformation functions, connect them via dependencies, visualize the entire pipeline, and execute them in topological order. The run_example function demonstrates this by building a simple question-answering and evaluation flow, showcasing the clarity and modularity of LangGraph’s architecture. def run_advanced_example(): """Run a more advanced example with multiple nodes for content generation""" graph = LangGraph() def topic_selector(state, **kwargs): return "Graph-based AI systems" graph.transform_node( name="topic_selector", transform_fn=topic_selector, outputs=["topic"] ) graph.claude_node( name="outline_generator", prompt_template="Create a brief outline for a technical blog post about {topic}. Include 3-4 main sections only.", inputs=["topic"], outputs=["outline"], system_prompt="You are a technical writer specializing in AI technologies." ) graph.claude_node( name="intro_writer", prompt_template="Write an engaging introduction for a blog post with this outline: {outline}\nTopic: {topic}", inputs=["topic", "outline"], outputs=["introduction"], system_prompt="You are a technical writer. Write in a clear, engaging style." ) graph.claude_node( name="conclusion_writer", prompt_template="Write a conclusion for a blog post with this outline: {outline}\nTopic: {topic}", inputs=["topic", "outline"], outputs=["conclusion"], system_prompt="You are a technical writer. Summarize key points and include a forward-looking statement." ) def assembler(state, introduction, outline, conclusion, **kwargs): return f"# {state['topic']}\n\n{introduction}\n\n## Outline\n{outline}\n\n## Conclusion\n{conclusion}" graph.transform_node( name="content_assembler", transform_fn=assembler, inputs=["topic", "introduction", "outline", "conclusion"], outputs=["final_content"] ) graph.visualize() result = graph.execute() print("\n" + "="*50) print("BLOG POST GENERATED:") print("="*50 + "\n") print(result.get("final_content")) print("\n" + "="*50) return graph The run_advanced_example function showcases a more sophisticated use of LangGraph by orchestrating multiple Claude-powered nodes to generate a complete blog post. It starts by selecting a topic, then creates an outline, an introduction, and a conclusion, all using structured Claude prompts. Finally, a transformation node assembles the content into a formatted blog post. This example demonstrates how LangGraph can automate complex, multi-step content generation tasks using modular, connected nodes in a clear and executable flow. print("1. Running simple question-answering example") question = "What are the three main advantages of using graph-based AI architectures?" simple_graph = run_example(question) print("\n2. Running advanced blog post creation example") advanced_graph = run_advanced_example() Finally, we trigger the execution of both defined LangGraph workflows. First, it runs the simple question-answering example by passing a predefined question to the run_example() function. Then, it initiates the more advanced blog post generation workflow using run_advanced_example(). Together, these calls demonstrate the practical flexibility of LangGraph, from basic prompt-based interactions to multi-step content automation using Anthropic’s Claude API. In conclusion, we have implemented LangGraph integrated with Anthropic’s Claude API, which illustrates the ease of designing modular AI workflows that leverage powerful language models in structured, graph-based pipelines. Through visualizing task flows and separating responsibilities among nodes, such as question processing, analytical evaluation, content outlining, and assembly, developers gain practical experience in building maintainable, scalable AI systems. LangGraph’s clear node dependencies and Claude’s sophisticated language capabilities provide an efficient solution for orchestrating complex AI processes, especially for rapid prototyping and execution in environments like Google Colab. Check out the Colab Notebook. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 95k+ ML SubReddit and Subscribe to our Newsletter. Asif RazzaqWebsite |  + postsBioAsif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is committed to harnessing the potential of Artificial Intelligence for social good. His most recent endeavor is the launch of an Artificial Intelligence Media Platform, Marktechpost, which stands out for its in-depth coverage of machine learning and deep learning news that is both technically sound and easily understandable by a wide audience. The platform boasts of over 2 million monthly views, illustrating its popularity among audiences.Asif Razzaqhttps://www.marktechpost.com/author/6flvq/Meta Researchers Introduced J1: A Reinforcement Learning Framework That Trains Language Models to Judge With Reasoned Consistency and Minimal DataAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Sampling Without Data is Now Scalable: Meta AI Releases Adjoint Sampling for Reward-Driven Generative ModelingAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Google AI Releases MedGemma: An Open Suite of Models Trained for Performance on Medical Text and Image ComprehensionAsif Razzaqhttps://www.marktechpost.com/author/6flvq/NVIDIA Releases Cosmos-Reason1: A Suite of AI Models Advancing Physical Common Sense and Embodied Reasoning in Real-World Environments

Large language models are now being used for evaluation and judgment tasks, extending beyond their traditional role of text generation. This has led to “LLM-as-a-Judge,” where models assess outputs from other language models. Such evaluations are essential in reinforcement learning pipelines, benchmark testing, and system alignment. These judge models rely on internal chain-of-thought reasoning, mirroring human judgment processes. Unlike conventional reward models that provide direct scores, these models simulate thoughtful evaluation, making them better suited for complex tasks such as math problem-solving, ethical reasoning, and user intent interpretation. Their ability to interpret and validate responses across languages and domains enhances automation and scalability in language model development. However, current AI judgment systems face issues with inconsistency and shallow reasoning. Many rely on basic metrics or static annotations, which are inadequate for evaluating subjective or open-ended prompts. A common problem is position bias, where the order of answers affects the final decision, compromising fairness. Also, collecting human-annotated data at scale is costly and time-consuming, limiting the generalizability of these models. Several existing approaches have addressed these challenges, but with limited success. Systems like EvalPlanner and DeepSeek-GRM rely on human-labeled data or rigid training schemes, which limit adaptability across task types. Others, like DeepSeek-R1, depend on distillation from large models but perform poorly on ambiguous prompts. Static datasets and offline tuning strategies hinder dynamic reasoning, while newer methods using score formatting or structured prompts have shown minimal accuracy improvements. Despite larger datasets and models, performance gains in traditional systems have stalled. Researchers from Meta’s GenAI and FAIR teams introduced J1 to address the above limitations. J1 trains judgment models through a reinforcement learning-based framework, making them capable of learning through verifiable reward signals. The team used synthetic data to create high-quality and low-quality responses to a prompt, transforming subjective tasks into verifiable pairwise judgments. This synthetic dataset included 22,000 preference pairs, split between 17,000 prompts from the WildChat corpus and 5,000 mathematical queries. These were used to train two versions of J1: J1-Llama-8B and J1-Llama-70B, initialized from the Llama-3.1-8B-Instruct and Llama-3.3-70B-Instruct base models, respectively. The models were trained using Group Relative Policy Optimization (GRPO), a reinforcement algorithm that eliminates the need for critic models and accelerates convergence. At the training strategy’s core is position-agnostic learning, where both (x, a, b) and (x, b, a) input formats are used in training to prevent position bias. Also, consistency-based rewards are applied only when the model delivers correct verdicts across both answer orderings. This structure allows the judge to be fair and reliable regardless of prompt or answer order. The training framework supports multiple variations: models can output final verdicts, numeric scores for each answer, or both. A pointwise judging variant is included, which evaluates single responses using scores from 0 to 10. These formats make J1 a versatile and generalizable system capable of judging various tasks. The results obtained using the J1 models reveal substantial performance improvements over existing systems. On the widely used Preference Proxy Evaluations (PPE) benchmark, J1-Llama-70B achieved an overall accuracy of 69.6%, outperforming models trained with over ten times more data. In contrast, models like DeepSeek-GRM-27B and EvalPlanner-Llama-70B scored 67.2% and 65.6%, respectively. Even the smaller J1-Llama-8B model exceeded baseline systems like EvalPlanner-Llama-8B, scoring 62.2% versus 55.5%. J1 also showed top-tier performance on other critical benchmarks such as RewardBench, RM-Bench, JudgeBench, and FollowBenchEval, demonstrating robust generalization across verifiable and subjective tasks. These improvements are not just marginal but significant, considering the limited training data used in J1 compared to the expansive datasets in other models. Several Key Takeaways from the Research on J1: J1 is trained using 22,000 synthetic preference pairs, including 17K from WildChat and 5K from MATH tasks. The training uses GRPO, which streamlines RL by avoiding the need for separate critic models. It introduces position-agnostic learning, reducing position bias through consistency-based rewards. Two main model variants, J1-Llama-8B and J1-Llama-70B, were trained on modest data but outperformed large-scale models. J1-Llama-70B scored 69.6% on PPE, exceeding DeepSeek-GRM-27B (67.2%) and EvalPlanner-Llama-70B (65.6%). Supports multiple judgment formats: pairwise with verdicts, pairwise with scores, and pointwise scores. Surpasses models distilled from DeepSeek-R1 and OpenAI’s o1-mini on several tasks. Demonstrates that reasoning quality, not just dataset size, is critical for accurate judgments. J1’s framework makes it a generalist judge applicable to verifiable and non-verifiable tasks. In conclusion, the J1 approach fundamentally redefines how judgment models are trained and evaluated. Synthetic data and reinforcement learning bypass the traditional need for costly annotations while promoting fair, logical, and consistent evaluations. This work illustrates that reasoning-driven judging can outperform larger models that rely heavily on data volume and static alignment techniques. It also validates the notion that judgment models should be thinkers first, and scorers second. With performance that rivals and often surpasses state-of-the-art systems, J1 sets a new benchmark in training LLM-as-a-Judge systems. Check out the Paper. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 95k+ ML SubReddit and Subscribe to our Newsletter. Asif RazzaqWebsite |  + postsBioAsif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is committed to harnessing the potential of Artificial Intelligence for social good. His most recent endeavor is the launch of an Artificial Intelligence Media Platform, Marktechpost, which stands out for its in-depth coverage of machine learning and deep learning news that is both technically sound and easily understandable by a wide audience. The platform boasts of over 2 million monthly views, illustrating its popularity among audiences.Asif Razzaqhttps://www.marktechpost.com/author/6flvq/Sampling Without Data is Now Scalable: Meta AI Releases Adjoint Sampling for Reward-Driven Generative ModelingAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Google AI Releases MedGemma: An Open Suite of Models Trained for Performance on Medical Text and Image ComprehensionAsif Razzaqhttps://www.marktechpost.com/author/6flvq/NVIDIA Releases Cosmos-Reason1: A Suite of AI Models Advancing Physical Common Sense and Embodied Reasoning in Real-World EnvironmentsAsif Razzaqhttps://www.marktechpost.com/author/6flvq/A Step-by-Step Coding Guide to Efficiently Fine-Tune Qwen3-14B Using Unsloth AI on Google Colab with Mixed Datasets and LoRA Optimization

Data Scarcity in Generative Modeling Generative models traditionally rely on large, high-quality datasets to produce samples that replicate the underlying data distribution. However, in fields like molecular modeling or physics-based inference, acquiring such data can be computationally infeasible or even impossible. Instead of labeled data, only a scalar reward—typically derived from a complex energy function—is available to judge the quality of generated samples. This presents a significant challenge: how can one train generative models effectively without direct supervision from data? Meta AI tackles this challenge with Adjoint Sampling, a novel learning algorithm designed for training generative models using only scalar reward signals. Built on the theoretical framework of stochastic optimal control (SOC), Adjoint Sampling reframes the training process as an optimization task over a controlled diffusion process. Unlike standard generative models, it does not require explicit data. Instead, it learns to generate high-quality samples by iteratively refining them using a reward function—often derived from physical or chemical energy models. Adjoint Sampling excels in scenarios where only an unnormalized energy function is accessible. It produces samples that align with the target distribution defined by this energy, bypassing the need for corrective methods like importance sampling or MCMC, which are computationally intensive. Source: https://arxiv.org/abs/2504.11713 Technical Details The foundation of Adjoint Sampling is a stochastic differential equation (SDE) that models how sample trajectories evolve. The algorithm learns a control drift u(x,t)u(x, t)u(x,t) such that the final state of these trajectories approximates a desired distribution (e.g., Boltzmann). A key innovation is its use of Reciprocal Adjoint Matching (RAM)—a loss function that enables gradient-based updates using only the initial and final states of sample trajectories. This sidesteps the need to backpropagate through the entire diffusion path, greatly improving computational efficiency. By sampling from a known base process and conditioning on terminal states, Adjoint Sampling constructs a replay buffer of samples and gradients, allowing multiple optimization steps per sample. This on-policy training method provides scalability unmatched by previous approaches, making it suitable for high-dimensional problems like molecular conformer generation. Moreover, Adjoint Sampling supports geometric symmetries and periodic boundary conditions, enabling models to respect molecular invariances like rotation, translation, and torsion. These features are crucial for physically meaningful generative tasks in chemistry and physics. Performance Insights and Benchmark Results Adjoint Sampling achieves state-of-the-art results in both synthetic and real-world tasks. On synthetic benchmarks such as the Double-Well (DW-4), Lennard-Jones (LJ-13 and LJ-55) potentials, it significantly outperforms baselines like DDS and PIS, especially in energy efficiency. For example, where DDS and PIS require 1000 evaluations per gradient update, Adjoint Sampling only uses three, with similar or better performance in Wasserstein distance and effective sample size (ESS). In a practical setting, the algorithm was evaluated on large-scale molecular conformer generation using the eSEN energy model trained on the SPICE-MACE-OFF dataset. Adjoint Sampling, especially its Cartesian variant with pretraining, achieved up to 96.4% recall and 0.60 Å mean RMSD, surpassing RDKit ETKDG—a widely used chemistry-based baseline—across all metrics. The method generalizes well to the GEOM-DRUGS dataset, showing substantial improvements in recall while maintaining competitive precision. The algorithm’s ability to explore the configuration space broadly, aided by its stochastic initialization and reward-based learning, results in greater conformer diversity—critical for drug discovery and molecular design. Conclusion: A Scalable Path Forward for Reward-Driven Generative Models Adjoint Sampling represents a major step forward in generative modeling without data. By leveraging scalar reward signals and an efficient on-policy training method grounded in stochastic control, it enables scalable training of diffusion-based samplers with minimal energy evaluations. Its integration of geometric symmetries and its ability to generalize across diverse molecular structures position it as a foundational tool in computational chemistry and beyond. Check out the Paper, Model on Hugging Face and GitHub Page. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 95k+ ML SubReddit and Subscribe to our Newsletter. Asif RazzaqWebsite |  + postsBioAsif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is committed to harnessing the potential of Artificial Intelligence for social good. His most recent endeavor is the launch of an Artificial Intelligence Media Platform, Marktechpost, which stands out for its in-depth coverage of machine learning and deep learning news that is both technically sound and easily understandable by a wide audience. The platform boasts of over 2 million monthly views, illustrating its popularity among audiences.Asif Razzaqhttps://www.marktechpost.com/author/6flvq/Google AI Releases MedGemma: An Open Suite of Models Trained for Performance on Medical Text and Image ComprehensionAsif Razzaqhttps://www.marktechpost.com/author/6flvq/NVIDIA Releases Cosmos-Reason1: A Suite of AI Models Advancing Physical Common Sense and Embodied Reasoning in Real-World EnvironmentsAsif Razzaqhttps://www.marktechpost.com/author/6flvq/A Step-by-Step Coding Guide to Efficiently Fine-Tune Qwen3-14B Using Unsloth AI on Google Colab with Mixed Datasets and LoRA OptimizationAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Chain-of-Thought May Not Be a Window into AI’s Reasoning: Anthropic’s New Study Reveals Hidden Gaps 🚨 Build GenAI you can trust. ⭐️ Parlant is your open-source engine for controlled, compliant, and purposeful AI conversations — Star Parlant on GitHub! (Promoted)

At Google I/O 2025, Google introduced MedGemma, an open suite of models designed for multimodal medical text and image comprehension. Built on the Gemma 3 architecture, MedGemma aims to provide developers with a robust foundation for creating healthcare applications that require integrated analysis of medical images and textual data. Model Variants and Architecture MedGemma is available in two configurations: MedGemma 4B: A 4-billion parameter multimodal model capable of processing both medical images and text. It employs a SigLIP image encoder pre-trained on de-identified medical datasets, including chest X-rays, dermatology images, ophthalmology images, and histopathology slides. The language model component is trained on diverse medical data to facilitate comprehensive understanding. MedGemma 27B: A 27-billion parameter text-only model optimized for tasks requiring deep medical text comprehension and clinical reasoning. This variant is exclusively instruction-tuned and is designed for applications that demand advanced textual analysis. Deployment and Accessibility Developers can access MedGemma models through Hugging Face, subject to agreeing to the Health AI Developer Foundations terms of use. The models can be run locally for experimentation or deployed as scalable HTTPS endpoints via Google Cloud’s Vertex AI for production-grade applications. Google provides resources, including Colab notebooks, to facilitate fine-tuning and integration into various workflows. Applications and Use Cases MedGemma serves as a foundational model for several healthcare-related applications: Medical Image Classification: The 4B model’s pre-training makes it suitable for classifying various medical images, such as radiology scans and dermatological images. Medical Image Interpretation: It can generate reports or answer questions related to medical images, aiding in diagnostic processes. Clinical Text Analysis: The 27B model excels in understanding and summarizing clinical notes, supporting tasks like patient triaging and decision support. Adaptation and Fine-Tuning While MedGemma provides strong baseline performance, developers are encouraged to validate and fine-tune the models for their specific use cases. Techniques such as prompt engineering, in-context learning, and parameter-efficient fine-tuning methods like LoRA can be employed to enhance performance. Google offers guidance and tools to support these adaptation processes. Conclusion MedGemma represents a significant step in providing accessible, open-source tools for medical AI development. By combining multimodal capabilities with scalability and adaptability, it offers a valuable resource for developers aiming to build applications that integrate medical image and text analysis. Check out the Models on Hugging Face and Project Page. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 95k+ ML SubReddit and Subscribe to our Newsletter. Asif RazzaqWebsite |  + postsBioAsif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is committed to harnessing the potential of Artificial Intelligence for social good. His most recent endeavor is the launch of an Artificial Intelligence Media Platform, Marktechpost, which stands out for its in-depth coverage of machine learning and deep learning news that is both technically sound and easily understandable by a wide audience. The platform boasts of over 2 million monthly views, illustrating its popularity among audiences.Asif Razzaqhttps://www.marktechpost.com/author/6flvq/NVIDIA Releases Cosmos-Reason1: A Suite of AI Models Advancing Physical Common Sense and Embodied Reasoning in Real-World EnvironmentsAsif Razzaqhttps://www.marktechpost.com/author/6flvq/A Step-by-Step Coding Guide to Efficiently Fine-Tune Qwen3-14B Using Unsloth AI on Google Colab with Mixed Datasets and LoRA OptimizationAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Chain-of-Thought May Not Be a Window into AI’s Reasoning: Anthropic’s New Study Reveals Hidden GapsAsif Razzaqhttps://www.marktechpost.com/author/6flvq/How to Build a Powerful and Intelligent Question-Answering System by Using Tavily Search API, Chroma, Google Gemini LLMs, and the LangChain Framework 🚨 Build GenAI you can trust. ⭐️ Parlant is your open-source engine for controlled, compliant, and purposeful AI conversations — Star Parlant on GitHub! (Promoted)

Google’s family of “open” AI models, Gemma, is growing. During Google I/O 2025 on Tuesday, Google took the wraps off Gemma 3n, a model designed to run “smoothly” on phones, laptops, and tablets. Available in preview starting Tuesday, Gemma 3n can handle audio, text, images, and videos, according to Google. Models efficient enough to run offline and without the need for computing in the cloud have gained steam in the AI community in recent years. Not only are they cheaper to use than large models, but they preserve privacy by eliminating the need to transfer data to a remote data center. During a keynote at I/O, Gemma Product Manager Gus Martins said that Gemma 3n can run on devices with less than 2GB of RAM. “Gemma 3n shares the same architecture as Gemini Nano, and is and is engineered for incredible performance,” he added. In addition to Gemma 3n, Google is releasing MedGemma through its Health AI Developer Foundations program. According to the company, MedGemma is its most capable open model for analyzing health-related text and images. “MedGemma [is] our […] collection of open models for multimodal [health] text and image understanding,” Martins said. “MedGemma works great across a range of image and text applications, so that developers […] can adapt the models for their own health apps.” Also on the horizon is SignGemma, an open model to translate sign language into spoken-language text. Google says that SignGemma will enable developers to create new apps and integrations for deaf and hard-of-hearing users. Techcrunch event Join us at TechCrunch Sessions: AI Secure your spot for our leading AI industry event with speakers from OpenAI, Anthropic, and Cohere. For a limited time, tickets are just $292 for an entire day of expert talks, workshops, and potent networking. Exhibit at TechCrunch Sessions: AI Secure your spot at TC Sessions: AI and show 1,200+ decision-makers what you’ve built — without the big spend. Available through May 9 or while tables last. Berkeley, CA | June 5 REGISTER NOW “SignGemma is a new family of models trained to translate sign language to spoken-language text, but it’s best at American Sign Language and English,” Martins said. “It’s the most capable sign language understanding model ever, and we can’t wait for you — developers and deaf and hard-of-hearing communities — to take this foundation and build with it.” Worth noting is that Gemma has been criticized for its custom, non-standard licensing terms, which some developers say have made using the models commercially a risky proposition. That hasn’t dissuaded developers from downloading Gemma models tens of millions of times collectively, however. Updated 2:40 p.m. Pacific: Added several quotes from Gemma Product Manager Gus Martins. Topics

Google’s family of “open” AI models, Gemma, is growing. During Google I/O 2025 on Tuesday, Google took the wraps off Gemma 3n, a model designed to run “smoothly” on phones, laptops, and tablets. Available in preview starting Tuesday, Gemma 3n can handle audio, text, images, and videos, according to Google. Models efficient enough to run offline and without the need for computing in the cloud have gained steam in the AI community in recent years. Not only are they cheaper to use than large models, but they preserve privacy by eliminating the need to transfer data to a remote data center. During a keynote at I/O, Gemma Product Manager Gus Martins said that Gemma 3n can run on devices with less than 2GB of RAM. “Gemma 3n shares the same architecture as Gemini Nano, and is and is engineered for incredible performance,” he added. In addition to Gemma 3n, Google is releasing MedGemma through its Health AI Developer Foundations program. According to the company, MedGemma is its most capable open model for analyzing health-related text and images. “MedGemma [is] our […] collection of open models for multimodal [health] text and image understanding,” Martins said. “MedGemma works great across a range of image and text applications, so that developers […] can adapt the models for their own health apps.” Also on the horizon is SignGemma, an open model to translate sign language into spoken-language text. Google says that SignGemma will enable developers to create new apps and integrations for deaf and hard-of-hearing users. Techcrunch event Join us at TechCrunch Sessions: AI Secure your spot for our leading AI industry event with speakers from OpenAI, Anthropic, and Cohere. For a limited time, tickets are just $292 for an entire day of expert talks, workshops, and potent networking. Exhibit at TechCrunch Sessions: AI Secure your spot at TC Sessions: AI and show 1,200+ decision-makers what you’ve built — without the big spend. Available through May 9 or while tables last. Berkeley, CA | June 5 REGISTER NOW “SignGemma is a new family of models trained to translate sign language to spoken-language text, but it’s best at American Sign Language and English,” Martins said. “It’s the most capable sign language understanding model ever, and we can’t wait for you — developers and deaf and hard-of-hearing communities — to take this foundation and build with it.” Worth noting is that Gemma has been criticized for its custom, non-standard licensing terms, which some developers say have made using the models commercially a risky proposition. That hasn’t dissuaded developers from downloading Gemma models tens of millions of times collectively, however. Updated 2:40 p.m. Pacific: Added several quotes from Gemma Product Manager Gus Martins. Topics